From: Haesu Gwon <haesu.gwon@samsung.com>
Date: Wed, 13 Jul 2016 05:33:12 +0000 (+0900)
Subject: [Release version 0.10.64] Fix Tizen coding rule violation
X-Git-Tag: submit/tizen/20160805.054353~4
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F13%2F79813%2F3;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git

[Release version 0.10.64] Fix Tizen coding rule violation

Change-Id: Ie0cfc8489bc2f9fe76e9881f8f838d73ba598479
Signed-off-by: Haesu Gwon <haesu.gwon@samsung.com>
---

diff --git a/packaging/libmm-camcorder.spec b/packaging/libmm-camcorder.spec
index 011522a..ff053ab 100644
--- a/packaging/libmm-camcorder.spec
+++ b/packaging/libmm-camcorder.spec
@@ -1,6 +1,6 @@
 Name:       libmm-camcorder
 Summary:    Camera and recorder library
-Version:    0.10.63
+Version:    0.10.64
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0
diff --git a/src/include/mm_camcorder.h b/src/include/mm_camcorder.h
index c9ad54e..27e6db6 100644
--- a/src/include/mm_camcorder.h
+++ b/src/include/mm_camcorder.h
@@ -43,7 +43,7 @@
 
 	@par
 	Recording state and paused state exists when the mode of camcorder is
-	video-capture or audio-capture mode. In case of image-capture mode, CAPTURING state will 
+	video-capture or audio-capture mode. In case of image-capture mode, CAPTURING state will
 	exsit.
 
 	@par
@@ -217,7 +217,7 @@
 		<td><center><b>Attribute</b></center></td>
 		<td><center><b>Description</b></center></td>
 	</tr>
-    	<tr>
+	<tr>
 		<td>#MMCAM_MODE</td>
 		<td>Mode of camcorder ( still/video/audio )</td>
 	</tr>
@@ -338,7 +338,7 @@
 		<td><center><b>Attribute</b></center></td>
 		<td><center><b>Description</b></center></td>
 	</tr>
-    	<tr>
+	<tr>
 		<td>#MMCAM_AUDIO_ENCODER_BITRATE</td>
 		<td>Bitrate of Audio Encoder</td>
 	</tr>
@@ -371,7 +371,7 @@
 		<td><center><b>Attribute</b></center></td>
 		<td><center><b>Description</b></center></td>
 	</tr>
-    	<tr>
+	<tr>
 		<td>#MMCAM_IMAGE_ENCODER_QUALITY</td>
 		<td>Encoding quality of Image codec</td>
 	</tr>
@@ -408,7 +408,7 @@
 		<td><center><b>Attribute</b></center></td>
 		<td><center><b>Description</b></center></td>
 	</tr>
-    	<tr>
+	<tr>
 		<td>#MMCAM_AUDIO_VOLUME</td>
 		<td>Input volume of audio source ( double value )</td>
 	</tr>
@@ -621,7 +621,7 @@ extern "C" {
 /**
  * Set fraction value. Definition for fraction setting, such as MMCAM_CAMERA_SHUTTER_SPEED and MMCAM_CAMERA_EXPOSURE_VALUE.
  */
-#define MM_CAMCORDER_SET_FRACTION(numerator,denominator)	((int)((((int)(numerator)) << 16) | (int)(denominator)))
+#define MM_CAMCORDER_SET_FRACTION(numerator, denominator)	((int)((((int)(numerator)) << 16) | (int)(denominator)))
 
 /* Attributes Macros */
 /**
@@ -1326,8 +1326,7 @@ typedef enum {
 /**
  * An enumeration of Audio Format.
  */
-typedef enum
-{
+typedef enum {
 	MM_CAMCORDER_AUDIO_FORMAT_PCM_U8 = 0,		/**< unsigned 8bit audio */
 	MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE = 2,	/**< signed 16bit audio. Little endian. */
 } MMCamcorderAudioFormat;
@@ -1543,7 +1542,7 @@ enum MMCamcorderGeometryMethod {
  * An enumeration for orientation values of tag .
  */
 enum MMCamcorderTagOrientation {
-	MM_CAMCORDER_TAG_ORT_NONE =0,		/**< No Orientation.*/
+	MM_CAMCORDER_TAG_ORT_NONE = 0,		/**< No Orientation.*/
 	MM_CAMCORDER_TAG_ORT_0R_VT_0C_VL,	/**< The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.*/
 	MM_CAMCORDER_TAG_ORT_0R_VT_0C_VR,	/**< The 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.*/
 	MM_CAMCORDER_TAG_ORT_0R_VB_0C_VR,	/**< The 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.*/
@@ -1558,7 +1557,7 @@ enum MMCamcorderTagOrientation {
  * An enumeration for captured video orientation values of tag .
  */
 enum MMCamcorderTagVideoOrientation {
-	MM_CAMCORDER_TAG_VIDEO_ORT_NONE =0,	/**< No Orientation.*/
+	MM_CAMCORDER_TAG_VIDEO_ORT_NONE = 0,	/**< No Orientation.*/
 	MM_CAMCORDER_TAG_VIDEO_ORT_90,		/**< 90 degree */
 	MM_CAMCORDER_TAG_VIDEO_ORT_180,	/**< 180 degree */
 	MM_CAMCORDER_TAG_VIDEO_ORT_270,	/**< 270 degree */
@@ -1616,13 +1615,13 @@ enum MMCamcorderPreviewType {
 /**
  * An enumeration for attribute values types.
  */
-typedef enum{
+typedef enum {
 	MM_CAM_ATTRS_TYPE_INVALID = -1,		/**< Type is invalid */
 	MM_CAM_ATTRS_TYPE_INT,			/**< Integer type attribute */
 	MM_CAM_ATTRS_TYPE_DOUBLE,		/**< Double type attribute */
 	MM_CAM_ATTRS_TYPE_STRING,		/**< UTF-8 String type attribute */
 	MM_CAM_ATTRS_TYPE_DATA,			/**< Pointer type attribute */
-}MMCamAttrsType;
+} MMCamAttrsType;
 
 
 /**
@@ -1951,7 +1950,7 @@ int mm_camcorder_create(MMHandleType *camcorder, MMCamPreset *info);
  *  This is the finalizing function of mm_camcorder. If this function is not called or fails to call, the handle isn't released fully.
  *  This function releases attributes, mutexes, sessions, and handle itself. This function also removes all of remaining messages.
  *  So if your application should wait a certain message of mm_camcorder, please wait to call this function till getting the message.
- *	
+ *
  *
  *	@param[in]	camcorder	A handle of camcorder.
  *	@return		This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
@@ -2500,7 +2499,7 @@ int mm_camcorder_stop(MMHandleType camcorder);
  *	@pre		Previous state of mm-camcorder should be MM_CAMCORDER_STATE_PREPARE
  *	@post		Next state of mm-camcorder will be MM_CAMCORDER_STATE_CAPTURING
  *	@remarks	To call this function, preview should be started successfully.\n
- *			This function is a pair of mm_camcorder_capture_stop(). 
+ *			This function is a pair of mm_camcorder_capture_stop().
  *			So user should call mm_camcorder_capture_stop() after getting captured image.
  *	@par example
  *	@code
@@ -2512,7 +2511,7 @@ gboolean capturing_picture()
 	int err;
 
 	err =  mm_camcorder_capture_start(hcam);
-	if (err < 0) 
+	if (err < 0)
 	{
 		printf("Fail to call mm_camcorder_capture_start  = %x\n", err);
 		return FALSE;
@@ -2900,7 +2899,7 @@ gboolean setting_audio_stream_callback()
 
 	return TRUE;
 }
- * 	@endcode
+ *  @endcode
  */
 int mm_camcorder_set_audio_stream_callback(MMHandleType camcorder, mm_camcorder_audio_stream_callback callback, void *user_data);
 
diff --git a/src/include/mm_camcorder_attribute.h b/src/include/mm_camcorder_attribute.h
index 65601e6..8daeb01 100644
--- a/src/include/mm_camcorder_attribute.h
+++ b/src/include/mm_camcorder_attribute.h
@@ -54,8 +54,7 @@ extern "C" {
 /**
  * Enumerations for camcorder attribute ID.
  */
-typedef enum
-{
+typedef enum {
 	MM_CAM_MODE,					/* 0 */
 	MM_CAM_AUDIO_DEVICE,
 	MM_CAM_CAMERA_DEVICE_COUNT,
@@ -187,7 +186,7 @@ typedef enum
 	MM_CAM_DISPLAY_REUSE_HINT,
 	MM_CAM_DISPLAY_REUSE_ELEMENT,
 	MM_CAM_ATTRIBUTE_NUM
-}MMCamcorderAttrsID;
+} MMCamcorderAttrsID;
 
 /*=======================================================================================
 | TYPE DEFINITIONS									|
diff --git a/src/include/mm_camcorder_exifinfo.h b/src/include/mm_camcorder_exifinfo.h
index efbdc97..10010af 100644
--- a/src/include/mm_camcorder_exifinfo.h
+++ b/src/include/mm_camcorder_exifinfo.h
@@ -49,14 +49,14 @@ typedef struct {
 | GLOBAL FUNCTION PROTOTYPES								|
 ========================================================================================*/
 /**
- * Create exif info 
+ * Create exif info
  *  @param[in] info exif info.
  * @return return int.
  */
 int mm_exif_create_exif_info(mm_exif_info_t **info);
 
 /**
- * Destroy exif info 
+ * Destroy exif info
  *  @param[in] info exif info.
  *  @return void
  */
diff --git a/src/include/mm_camcorder_gstcommon.h b/src/include/mm_camcorder_gstcommon.h
index 3ee896d..48b4305 100644
--- a/src/include/mm_camcorder_gstcommon.h
+++ b/src/include/mm_camcorder_gstcommon.h
@@ -62,10 +62,10 @@ typedef enum _MMCamcorderAMRBitRate {
 * Encodebin profile
 */
 typedef enum _MMCamcorderEncodebinProfile {
-        MM_CAMCORDER_ENCBIN_PROFILE_VIDEO = 0,  /**< Video recording profile */
-        MM_CAMCORDER_ENCBIN_PROFILE_AUDIO,      /**< Audio recording profile */
-        MM_CAMCORDER_ENCBIN_PROFILE_IMAGE,      /**< Image capture profile */
-        MM_CAMCORDER_ENCBIN_PROFILE_NUM
+	MM_CAMCORDER_ENCBIN_PROFILE_VIDEO = 0,  /**< Video recording profile */
+	MM_CAMCORDER_ENCBIN_PROFILE_AUDIO,      /**< Audio recording profile */
+	MM_CAMCORDER_ENCBIN_PROFILE_IMAGE,      /**< Image capture profile */
+	MM_CAMCORDER_ENCBIN_PROFILE_NUM
 } MMCamcorderEncodebinProfile;
 
 /*=======================================================================================
diff --git a/src/include/mm_camcorder_internal.h b/src/include/mm_camcorder_internal.h
index 6b35d1c..851a3ec 100644
--- a/src/include/mm_camcorder_internal.h
+++ b/src/include/mm_camcorder_internal.h
@@ -72,33 +72,30 @@ extern "C" {
 /*=======================================================================================
 | MACRO DEFINITIONS									|
 ========================================================================================*/
-#define _mmcam_dbg_verb(fmt, args...)  debug_verbose (" "fmt"\n", ##args);
-#define _mmcam_dbg_log(fmt, args...)   debug_log (" "fmt"\n", ##args);
-#define _mmcam_dbg_warn(fmt, args...)  debug_warning (" "fmt"\n", ##args);
-#define _mmcam_dbg_err(fmt, args...)   debug_error (" "fmt"\n", ##args);
-#define _mmcam_dbg_crit(fmt, args...)  debug_critical (" "fmt"\n", ##args);
+#define _mmcam_dbg_verb(fmt, args...)  debug_verbose(" "fmt"\n", ##args);
+#define _mmcam_dbg_log(fmt, args...)   debug_log(" "fmt"\n", ##args);
+#define _mmcam_dbg_warn(fmt, args...)  debug_warning(" "fmt"\n", ##args);
+#define _mmcam_dbg_err(fmt, args...)   debug_error(" "fmt"\n", ##args);
+#define _mmcam_dbg_crit(fmt, args...)  debug_critical(" "fmt"\n", ##args);
 
 /**
  *	Macro for checking validity and debugging
  */
-#define mmf_return_if_fail( expr )	\
-	if( expr ){}					\
-	else						\
-	{							\
-		_mmcam_dbg_err( "failed [%s]", #expr);	\
-		return;						\
-	};
+#define mmf_return_if_fail(expr) \
+	if (!(expr)) { \
+		_mmcam_dbg_err("failed [%s]", #expr); \
+		return; \
+	}
 
 /**
  *	Macro for checking validity and debugging
  */
-#define mmf_return_val_if_fail( expr, val )	\
-	if( expr ){}					\
-	else						\
-	{							\
-		_mmcam_dbg_err("failed [%s]", #expr);	\
-		return( val );						\
-	};
+#define mmf_return_val_if_fail(expr, val) \
+	if (!(expr)) { \
+		_mmcam_dbg_err("failed [%s]", #expr); \
+		return (val); \
+	}
+
 
 #ifndef ARRAY_SIZE
 /**
@@ -235,52 +232,52 @@ extern "C" {
 #define _MM_GST_ELEMENT_UNLINK          gst_element_unlink
 #define _MM_GST_PAD_LINK                gst_pad_link
 
-#define _MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, if_fail_goto)\
-{\
-	GstPadLinkReturn ret = GST_PAD_LINK_OK;\
-	if (srcpad == NULL || sinkpad == NULL) {\
-		if (srcpad == NULL) {\
-			_mmcam_dbg_err("srcpad is NULL");\
-		} else {\
+#define _MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, if_fail_goto) \
+{ \
+	GstPadLinkReturn ret = GST_PAD_LINK_OK; \
+	if (srcpad == NULL || sinkpad == NULL) { \
+		if (srcpad == NULL) { \
+			_mmcam_dbg_err("srcpad is NULL"); \
+		} else { \
 			gst_object_unref(srcpad);\
-			srcpad = NULL;\
-		}\
-		if (sinkpad == NULL) {\
-			_mmcam_dbg_err("sinkpad is NULL");\
-		} else {\
-			gst_object_unref(sinkpad);\
+			srcpad = NULL; \
+		} \
+		if (sinkpad == NULL) { \
+			_mmcam_dbg_err("sinkpad is NULL"); \
+		} else { \
+			gst_object_unref(sinkpad); \
 			sinkpad = NULL;\
-		}\
-		err = MM_ERROR_CAMCORDER_GST_LINK;\
-		goto if_fail_goto;\
-	}\
-	ret = _MM_GST_PAD_LINK(srcpad, sinkpad);\
-	if (ret != GST_PAD_LINK_OK) {\
-		GstObject *src_parent = gst_pad_get_parent(srcpad);\
-		GstObject *sink_parent = gst_pad_get_parent(sinkpad);\
-		char *src_name = NULL;\
-		char *sink_name = NULL;\
-		g_object_get((GObject *)src_parent, "name", &src_name, NULL);\
-		g_object_get((GObject *)sink_parent, "name", &sink_name, NULL);\
-		_mmcam_dbg_err("src[%s] - sink[%s] link failed", src_name, sink_name);\
-		gst_object_unref(src_parent); src_parent = NULL;\
-		gst_object_unref(sink_parent); sink_parent = NULL;\
-		if (src_name) {\
-			free(src_name); src_name = NULL;\
-		}\
-		if (sink_name) {\
-			free(sink_name); sink_name = NULL;\
-		}\
-		gst_object_unref(srcpad); srcpad = NULL;\
-		gst_object_unref(sinkpad); sinkpad = NULL;\
-		err = MM_ERROR_CAMCORDER_GST_LINK;\
+		} \
+		err = MM_ERROR_CAMCORDER_GST_LINK; \
+		goto if_fail_goto; \
+	} \
+	ret = _MM_GST_PAD_LINK(srcpad, sinkpad); \
+	if (ret != GST_PAD_LINK_OK) { \
+		GstObject *src_parent = gst_pad_get_parent(srcpad); \
+		GstObject *sink_parent = gst_pad_get_parent(sinkpad); \
+		char *src_name = NULL; \
+		char *sink_name = NULL; \
+		g_object_get((GObject *)src_parent, "name", &src_name, NULL); \
+		g_object_get((GObject *)sink_parent, "name", &sink_name, NULL); \
+		_mmcam_dbg_err("src[%s] - sink[%s] link failed", src_name, sink_name); \
+		gst_object_unref(src_parent); src_parent = NULL; \
+		gst_object_unref(sink_parent); sink_parent = NULL; \
+		if (src_name) { \
+			free(src_name); src_name = NULL; \
+		} \
+		if (sink_name) { \
+			free(sink_name); sink_name = NULL; \
+		} \
+		gst_object_unref(srcpad); srcpad = NULL; \
+		gst_object_unref(sinkpad); sinkpad = NULL; \
+		err = MM_ERROR_CAMCORDER_GST_LINK; \
 		goto if_fail_goto;\
-	}\
-	gst_object_unref(srcpad); srcpad = NULL;\
-	gst_object_unref(sinkpad); sinkpad = NULL;\
+	} \
+	gst_object_unref(srcpad); srcpad = NULL; \
+	gst_object_unref(sinkpad); sinkpad = NULL; \
 }
 
-#define _MM_GST_PAD_UNLINK_UNREF( srcpad, sinkpad) \
+#define _MM_GST_PAD_UNLINK_UNREF(srcpad, sinkpad) \
 	if (srcpad && sinkpad) { \
 		gst_pad_unlink(srcpad, sinkpad); \
 	} else { \
@@ -688,8 +685,8 @@ typedef struct mmf_camcorder {
 	int device_type;        /**< device type */
 	int state;              /**< state of camcorder */
 	int target_state;       /**< Target state that want to set. This is a flag that
-	                           * stands for async state changing. If this value differ from state,
-	                           * it means state is changing now asychronously. */
+							   * stands for async state changing. If this value differ from state,
+							   * it means state is changing now asychronously. */
 
 	/* handles */
 	MMHandleType attributes;               /**< Attribute handle */
@@ -724,8 +721,8 @@ typedef struct mmf_camcorder {
 
 	/* etc */
 	mm_cam_attr_construct_info *cam_attrs_const_info;       /**< attribute info */
-	conf_info_table* conf_main_info_table[CONFIGURE_CATEGORY_MAIN_NUM]; /** configure info table - MAIN category */
-	conf_info_table* conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_NUM]; /** configure info table - CONTROL category */
+	conf_info_table *conf_main_info_table[CONFIGURE_CATEGORY_MAIN_NUM]; /** configure info table - MAIN category */
+	conf_info_table *conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_NUM]; /** configure info table - CONTROL category */
 	int conf_main_category_size[CONFIGURE_CATEGORY_MAIN_NUM]; /** configure info table size - MAIN category */
 	int conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_NUM]; /** configure info table size - CONTROL category */
 	_MMCamcorderMTSafe mtsafe;                              /**< Thread safe */
@@ -947,7 +944,7 @@ int _mmcamcorder_commit(MMHandleType hcamcorder);
 int _mmcamcorder_cancel(MMHandleType hcamcorder);
 
 /**
- *	This function calls after commiting action finished asynchronously. 
+ *	This function calls after commiting action finished asynchronously.
  *	In this function, remaining process , such as state change, happens.
  *
  *	@param[in]	hcamcorder	Specifies the camcorder  handle
@@ -970,15 +967,15 @@ int _mmcamcorder_commit_async_end(MMHandleType hcamcorder);
  *	@return		This function returns zero on success, or negative value with error code.
  *	@remarks	typedef bool (*mm_message_callback) (int msg, mm_messageType *param, void *user_param);@n
  *		@n
- *		typedef union 				@n
+ *		typedef union				@n
  *		{							@n
  *			int code;				@n
- *			struct 					@n
+ *			struct					@n
  *			{						@n
  *				int total;			@n
  *				int elapsed;		@n
  *			} time;					@n
- *			struct 					@n
+ *			struct					@n
  *			{						@n
  *				int previous;		@n
  *				int current;			@n
@@ -1259,10 +1256,10 @@ int _mmcamcorder_video_average_framerate(MMHandleType handle);
 /* sound focus related function */
 void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder);
 void _mmcamcorder_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);
 void _mmcamcorder_sound_focus_watch_cb(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);
+	const char *reason_for_change, const char *additional_info, void *user_data);
 
 /* device policy manager */
 void _mmcamcorder_dpm_camera_policy_changed_cb(const char *name, const char *value, void *user_data);
diff --git a/src/include/mm_camcorder_platform.h b/src/include/mm_camcorder_platform.h
index bfcb88b..f375ca9 100644
--- a/src/include/mm_camcorder_platform.h
+++ b/src/include/mm_camcorder_platform.h
@@ -37,7 +37,7 @@ extern "C" {
 /*=======================================================================================
 | GLOBAL DEFINITIONS AND DECLARATIONS FOR CAMCORDER					|
 ========================================================================================*/
-#define 	MM_CAMCORDER_ATTR_NONE	-1
+#define MM_CAMCORDER_ATTR_NONE -1
 
 
 /*=======================================================================================
@@ -142,7 +142,7 @@ extern "C" {
 /**
  * Default None value for camera sensor enumeration.
  */
-#define _MMCAMCORDER_SENSOR_ENUM_NONE 	-255
+#define _MMCAMCORDER_SENSOR_ENUM_NONE	-255
 
 /* camera information related */
 #define CAMINFO_CONVERT_NUM		45
diff --git a/src/include/mm_camcorder_stillshot.h b/src/include/mm_camcorder_stillshot.h
index 5fe834c..58a9a62 100644
--- a/src/include/mm_camcorder_stillshot.h
+++ b/src/include/mm_camcorder_stillshot.h
@@ -135,7 +135,7 @@ int _mmcamcorder_video_capture_command(MMHandleType handle, int command);
 
 /* Function for capture */
 int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int image_height);
-int __mmcamcorder_update_exif_info(MMHandleType handle,void* imagedata, int imgln);
+int __mmcamcorder_update_exif_info(MMHandleType handle, void *imagedata, int imgln);
 void __mmcamcorder_init_stillshot_info(MMHandleType handle);
 void __mmcamcorder_get_capture_data_from_buffer(MMCamcorderCaptureDataType *capture_data, int pixtype, GstSample *sample);
 void __mmcamcorder_release_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType *dest, int tag_enable, int provide_exif);
diff --git a/src/include/mm_camcorder_util.h b/src/include/mm_camcorder_util.h
index bb1bfbc..042bf07 100644
--- a/src/include/mm_camcorder_util.h
+++ b/src/include/mm_camcorder_util.h
@@ -41,7 +41,7 @@ extern "C" {
 | MACRO DEFINITIONS									|
 ========================================================================================*/
 #ifndef CLEAR
-#define CLEAR(x)            memset (&(x), 0, sizeof (x))
+#define CLEAR(x)            memset(&(x), 0, sizeof(x))
 #endif
 
 #define MMCAMCORDER_ADD_BUFFER_PROBE(x_pad, x_category, x_callback, x_hcamcorder) \
@@ -57,7 +57,8 @@ do { \
 		item->category = x_category; \
 		item->handler_id = gst_pad_add_probe(x_pad, GST_PAD_PROBE_TYPE_BUFFER, x_callback, x_hcamcorder, NULL); \
 		x_hcamcorder->buffer_probes = g_list_append(x_hcamcorder->buffer_probes, item); \
-		_mmcam_dbg_log("Adding buffer probe on [%s:%s] - [ID : %lu], [Category : %x] ", GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); \
+		_mmcam_dbg_log("Adding buffer probe on [%s:%s] - [ID : %lu], [Category : %x] ", \
+			GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); \
 	} \
 } while (0);
 
@@ -71,50 +72,52 @@ do { \
 	else if (x_category == 0 || !(x_category & _MMCAMCORDER_HANDLER_CATEGORY_ALL)) { \
 		_mmcam_dbg_err("Invalid handler category : %x \n", x_category); \
 	} else { \
-		item->object =G_OBJECT(x_pad); \
+		item->object = G_OBJECT(x_pad); \
 		item->category = x_category; \
 		item->handler_id = gst_pad_add_probe(x_pad, GST_PAD_PROBE_TYPE_EVENT_BOTH, x_callback, x_hcamcorder, NULL); \
 		x_hcamcorder->event_probes = g_list_append(x_hcamcorder->event_probes, item); \
-		_mmcam_dbg_log("Adding event probe on [%s:%s] - [ID : %lu], [Category : %x] ", GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); \
+		_mmcam_dbg_log("Adding event probe on [%s:%s] - [ID : %lu], [Category : %x] ", \
+			GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); \
 	} \
 } while (0);
 
-#define MMCAMCORDER_SIGNAL_CONNECT( x_object, x_category, x_signal, x_callback, x_hcamcorder) \
+#define MMCAMCORDER_SIGNAL_CONNECT(x_object, x_category, x_signal, x_callback, x_hcamcorder) \
 do { \
 	MMCamcorderHandlerItem* item = NULL; \
 	item = (MMCamcorderHandlerItem *) g_malloc(sizeof(MMCamcorderHandlerItem)); \
 	if (!item) { \
-		_mmcam_dbg_err("Cannot connect signal [%s]\n", x_signal ); \
+		_mmcam_dbg_err("Cannot connect signal [%s]\n", x_signal); \
 	} else if (x_category == 0 || !(x_category & _MMCAMCORDER_HANDLER_CATEGORY_ALL)) { \
 		_mmcam_dbg_err("Invalid handler category : %x \n", x_category); \
 	} else { \
 		item->object = G_OBJECT(x_object); \
 		item->category = x_category; \
-		item->handler_id = g_signal_connect(G_OBJECT(x_object), x_signal,\
-						    G_CALLBACK(x_callback), x_hcamcorder ); \
+		item->handler_id = g_signal_connect(G_OBJECT(x_object), x_signal, \
+			G_CALLBACK(x_callback), x_hcamcorder); \
 		x_hcamcorder->signals = g_list_append(x_hcamcorder->signals, item); \
-		_mmcam_dbg_log("Connecting signal on [%s][%p] - [ID : %lu], [Category : %x] ", GST_OBJECT_NAME(item->object), item->object, item->handler_id, item->category); \
+		_mmcam_dbg_log("Connecting signal on [%s][%p] - [ID : %lu], [Category : %x] ", \
+			GST_OBJECT_NAME(item->object), item->object, item->handler_id, item->category); \
 	} \
 } while (0);
 
 #define MMCAMCORDER_G_OBJECT_GET(obj, name, value) \
 do { \
 	if (obj) { \
-		if(g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(obj)), name)) { \
+		if (g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(obj)), name)) { \
 			g_object_get(G_OBJECT(obj), name, value, NULL); \
 		} else { \
-			_mmcam_dbg_warn ("The object doesn't have a property named(%s)", name); \
+			_mmcam_dbg_warn("The object doesn't have a property named(%s)", name); \
 		} \
 	} else { \
 		_mmcam_dbg_err("Null object"); \
 	} \
-} while(0);
+} while (0);
 
 #define MMCAMCORDER_G_OBJECT_SET(obj, name, value) \
 do { \
 	if (obj) { \
 		GParamSpec *spec = g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(obj)), name);\
-		if(spec) { \
+		if (spec) { \
 			if (spec->value_type == G_TYPE_INT64) {\
 				g_object_set(G_OBJECT(obj), name, (gint64)value, NULL); \
 			} else if (spec->value_type == G_TYPE_UINT64) { \
@@ -127,33 +130,33 @@ do { \
 				g_object_set(G_OBJECT(obj), name, value, NULL); \
 			} \
 		} else { \
-			_mmcam_dbg_warn ("The object doesn't have a property named(%s)", name); \
+			_mmcam_dbg_warn("The object doesn't have a property named(%s)", name); \
 		} \
 	} else { \
 		_mmcam_dbg_err("Null object"); \
 	} \
-} while(0);
+} while (0);
 
 #define MMCAMCORDER_G_OBJECT_SET_POINTER(obj, name, value) \
 do { \
 	if (obj) { \
 		GParamSpec *spec = g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(obj)), name);\
-		if(spec) { \
+		if (spec) { \
 			g_object_set(G_OBJECT(obj), name, value, NULL); \
 		} else { \
-			_mmcam_dbg_warn ("The object doesn't have a property named(%s)", name); \
+			_mmcam_dbg_warn("The object doesn't have a property named(%s)", name); \
 		} \
 	} else { \
 		_mmcam_dbg_err("Null object"); \
 	} \
-} while(0);
+} while (0);
 
-#define MMCAM_FOURCC(a,b,c,d)  (guint32)((a)|(b)<<8|(c)<<16|(d)<<24)
+#define MMCAM_FOURCC(a, b, c, d)  (guint32)((a)|(b)<<8|(c)<<16|(d)<<24)
 #define MMCAM_FOURCC_ARGS(fourcc) \
-        ((gchar)((fourcc)&0xff)), \
-        ((gchar)(((fourcc)>>8)&0xff)), \
-        ((gchar)(((fourcc)>>16)&0xff)), \
-        ((gchar)(((fourcc)>>24)&0xff))
+		((gchar)((fourcc)&0xff)), \
+		((gchar)(((fourcc)>>8)&0xff)), \
+		((gchar)(((fourcc)>>16)&0xff)), \
+		((gchar)(((fourcc)>>24)&0xff))
 
 #define MMCAM_SEND_MESSAGE(handle, msg_id, msg_code) \
 {\
@@ -276,7 +279,7 @@ gboolean _mmcamcorder_find_fourcc(FILE *f, guint32 tag_fourcc, gboolean do_rewin
 gint32 _mmcamcorder_double_to_fix(gdouble d_number);
 gboolean _mmcamcorder_update_size(FILE *f, gint64 prev_pos, gint64 curr_pos);
 gboolean _mmcamcorder_write_loci(FILE *f, _MMCamcorderLocationInfo info);
-gboolean _mmcamcorder_write_geodata(FILE *f,_MMCamcorderLocationInfo info);
+gboolean _mmcamcorder_write_geodata(FILE *f, _MMCamcorderLocationInfo info);
 gboolean _mmcamcorder_write_udta(FILE *f, int gps_enable, _MMCamcorderLocationInfo info, _MMCamcorderLocationInfo geotag);
 guint64 _mmcamcorder_get_container_size(const guchar *size);
 guint64 _mmcamcorder_get_container_size64(const guchar *size);
diff --git a/src/mm_camcorder.c b/src/mm_camcorder.c
index 34bad5e..22086ad 100644
--- a/src/mm_camcorder.c
+++ b/src/mm_camcorder.c
@@ -321,7 +321,7 @@ int mm_camcorder_set_audio_stream_callback(MMHandleType camcorder, mm_camcorder_
 
 int mm_camcorder_set_video_capture_callback(MMHandleType camcorder, mm_camcorder_video_capture_callback callback, void* user_data)
 {
-	mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
+	mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 
 	return _mmcamcorder_set_video_capture_callback(camcorder, callback, user_data);
 }
@@ -352,7 +352,7 @@ int mm_camcorder_get_attributes(MMHandleType camcorder, char **err_attr_name, co
 
 	va_start(var_args, attribute_name);
 	ret = _mmcamcorder_get_attributes(camcorder, err_attr_name, attribute_name, var_args);
-	va_end (var_args);
+	va_end(var_args);
 
 	return ret;
 }
@@ -365,9 +365,9 @@ int mm_camcorder_set_attributes(MMHandleType camcorder,  char **err_attr_name, c
 
 	return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 
-	va_start (var_args, attribute_name);
+	va_start(var_args, attribute_name);
 	ret = _mmcamcorder_set_attributes(camcorder, err_attr_name, attribute_name, var_args);
-	va_end (var_args);
+	va_end(var_args);
 
 	return ret;
 }
@@ -396,7 +396,7 @@ int mm_camcorder_init_focusing(MMHandleType camcorder)
 }
 
 
-int mm_camcorder_start_focusing( MMHandleType camcorder )
+int mm_camcorder_start_focusing(MMHandleType camcorder)
 {
 	int error = MM_ERROR_NONE;
 
diff --git a/src/mm_camcorder_attribute.c b/src/mm_camcorder_attribute.c
index 6a72c7a..6179726 100644
--- a/src/mm_camcorder_attribute.c
+++ b/src/mm_camcorder_attribute.c
@@ -46,7 +46,7 @@
 /*-----------------------------------------------------------------------
 |    LOCAL VARIABLE DEFINITIONS for internal				|
 -----------------------------------------------------------------------*/
-/* 	Readonly attributes list.
+/*	Readonly attributes list.
 *	If you want to make some attributes read only, write down here.
 *	It will make them read only after composing whole attributes.
 */
@@ -82,9 +82,9 @@ static int  __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_
 |    GLOBAL FUNCTION DEFINITIONS:					|
 -----------------------------------------------------------------------*/
 MMHandleType
-_mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
+_mmcamcorder_alloc_attribute(MMHandleType handle, MMCamPreset *info)
 {
-	_mmcam_dbg_log( "" );
+	_mmcam_dbg_log("");
 
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	MMHandleType attrs = 0;
@@ -96,8 +96,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 	static int flip_list[] = { MM_FLIP_NONE };
 	static int rotation_list[] = { MM_VIDEO_INPUT_ROTATION_NONE };
 	static int visible_values[] = { 0, 1 };	/*0: off, 1:on*/
-	static int tag_orientation_values[] =
-		{
+	static int tag_orientation_values[] = {
 			1,	/*The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.*/
 			2,	/*the 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.*/
 			3,	/*the 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.*/
@@ -135,7 +134,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 
 	/* basic attributes' info */
 	mm_cam_attr_construct_info temp_info[] = {
-		//0
+		/* 0 */
 		{
 			MM_CAM_MODE,                        /* ID */
 			"mode",                             /* Name */
@@ -246,7 +245,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{ARRAY_SIZE(depth)},
 			NULL,
 		},
-		//10
+		/* 10 */
 		{
 			MM_CAM_AUDIO_CHANNEL,
 			"audio-channel",
@@ -357,7 +356,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{.int_max = -1},
 			_mmcamcorder_commit_filter,
 		},
-		//20
+		/* 20 */
 		{
 			MM_CAM_FILTER_SHARPNESS,
 			"filter-sharpness",
@@ -468,7 +467,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{0},
 			_mmcamcorder_commit_camera_af_scan_range,
 		},
-		//30
+		/* 30 */
 		{
 			MM_CAM_CAMERA_EXPOSURE_MODE,
 			"camera-exposure-mode",
@@ -579,7 +578,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{.int_max = _MMCAMCORDER_MAX_INT},
 			NULL,
 		},
-		// 40
+		/* 40 */
 		{
 			MM_CAM_VIDEO_ENCODER_BITRATE,
 			"video-encoder-bitrate",
@@ -690,7 +689,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{0},
 			NULL,
 		},
-		// 50
+		/* 50 */
 		{
 			MM_CAM_DISPLAY_SURFACE,
 			"display-surface",
@@ -801,7 +800,8 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{.int_max = MM_DISPLAY_ROTATION_270},
 			_mmcamcorder_commit_display_rotation,
 		},
-		{ // 60
+		/* 60 */
+		{
 			MM_CAM_DISPLAY_VISIBLE,
 			"display-visible",
 			MMF_VALUE_TYPE_INT,
@@ -911,7 +911,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{0},
 			NULL,
 		},
-		//70
+		/* 70 */
 		{
 			MM_CAM_TAG_LATITUDE,
 			"tag-latitude",
@@ -1022,7 +1022,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{.int_max = -1},
 			_mmcamcorder_commit_detect,
 		},
-		//80
+		/* 80 */
 		{
 			MM_CAM_DETECT_STATUS,
 			"detect-status",
@@ -1133,7 +1133,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{.int_max = 1},
 			NULL,
 		},
-		// 90
+		/* 90 */
 		{
 			MM_CAM_TAG_GPS_TIME_STAMP,
 			"tag-gps-time-stamp",
@@ -1244,7 +1244,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{0},
 			_mmcamcorder_commit_display_mode,
 		},
-		//100
+		/* 100 */
 		{
 			MM_CAM_AUDIO_DISABLE,
 			"audio-disable",
@@ -1355,7 +1355,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{.int_max = MM_CAMCORDER_TAG_VIDEO_ORT_270},
 			NULL,
 		},
-		//110
+		/* 110 */
 		{
 			MM_CAM_CAMERA_PAN_MECHA,
 			"camera-pan-mecha",
@@ -1466,6 +1466,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{.int_max = TRUE},
 			NULL,
 		},
+		/* 120 */
 		{
 			MM_CAM_ENCODED_PREVIEW_BITRATE,
 			"encoded-preview-bitrate",
@@ -1488,7 +1489,6 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 			{.int_max = _MMCAMCORDER_MAX_INT},
 			_mmcamcorder_commit_encoded_preview_gop_interval,
 		},
-		//120
 		{
 			MM_CAM_RECORDER_TAG_ENABLE,
 			"recorder-tag-enable",
@@ -1602,10 +1602,10 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 	_mmcam_dbg_log("Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count);
 
 	attrs = mmf_attrs_new_from_data("Camcorder_Attributes",
-	                                attrs_const_info,
-	                                attr_count,
-	                                _mmcamcorder_commit_camcorder_attrs,
-	                                (void *)handle);
+		attrs_const_info,
+		attr_count,
+		_mmcamcorder_commit_camcorder_attrs,
+		(void *)handle);
 
 	free(attrs_const_info);
 	attrs_const_info = NULL;
@@ -1619,50 +1619,48 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
 
 	__mmcamcorder_set_conf_to_valid_info(handle);
 
-	for (idx = 0; idx < attr_count; idx++)
-	{
+	for (idx = 0; idx < attr_count; idx++) {
 /*		_mmcam_dbg_log("Valid type [%s:%d, %d, %d]", cam_attrs_const_info[idx].name, cam_attrs_const_info[idx].validity_type
 			, cam_attrs_const_info[idx].validity_value1, cam_attrs_const_info[idx].validity_value2);
 */
-		mmf_attrs_set_valid_type (attrs, idx, hcamcorder->cam_attrs_const_info[idx].validity_type);
-
-		switch (hcamcorder->cam_attrs_const_info[idx].validity_type)
-		{
-			case MM_ATTRS_VALID_TYPE_INT_ARRAY:
-				if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array &&
-				    hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
-					mmf_attrs_set_valid_array(attrs, idx,
-					                          (const int *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array),
-					                          hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
-					                          hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
-				}
+		mmf_attrs_set_valid_type(attrs, idx, hcamcorder->cam_attrs_const_info[idx].validity_type);
+
+		switch (hcamcorder->cam_attrs_const_info[idx].validity_type) {
+		case MM_ATTRS_VALID_TYPE_INT_ARRAY:
+			if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array &&
+			    hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
+				mmf_attrs_set_valid_array(attrs, idx,
+					(const int *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array),
+					hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
+					hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
+			}
 			break;
-			case MM_ATTRS_VALID_TYPE_INT_RANGE:
-				mmf_attrs_set_valid_range(attrs, idx,
-				                          hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_min,
-				                          hcamcorder->cam_attrs_const_info[idx].validity_value_2.int_max,
-					                  hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
+		case MM_ATTRS_VALID_TYPE_INT_RANGE:
+			mmf_attrs_set_valid_range(attrs, idx,
+				hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_min,
+				hcamcorder->cam_attrs_const_info[idx].validity_value_2.int_max,
+				hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
 			break;
-			case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
-				if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array &&
-				    hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
-					mmf_attrs_set_valid_double_array(attrs, idx,
-					                                 (const double *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array),
-					                                 hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
-					                                 hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
-				}
+		case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
+			if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array &&
+			    hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
+				mmf_attrs_set_valid_double_array(attrs, idx,
+					(const double *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array),
+					hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
+					hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
+			}
 			break;
-			case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
-				mmf_attrs_set_valid_double_range(attrs, idx,
-				                                 hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_min,
-				                                 hcamcorder->cam_attrs_const_info[idx].validity_value_2.double_max,
-				                                 hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
+		case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
+			mmf_attrs_set_valid_double_range(attrs, idx,
+				hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_min,
+				hcamcorder->cam_attrs_const_info[idx].validity_value_2.double_max,
+				hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
 			break;
-			case MM_ATTRS_VALID_TYPE_NONE:
+		case MM_ATTRS_VALID_TYPE_NONE:
 			break;
-			case MM_ATTRS_VALID_TYPE_INVALID:
-			default:
-				_mmcam_dbg_err("Valid type error.");
+		case MM_ATTRS_VALID_TYPE_INVALID:
+		default:
+			_mmcam_dbg_err("Valid type error.");
 			break;
 		}
 	}
@@ -1704,11 +1702,11 @@ _mmcamcorder_get_attributes(MMHandleType handle,  char **err_attr_name, const ch
 	MMHandleType attrs = 0;
 	int ret = MM_ERROR_NONE;
 
-	mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
-//	mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
+	mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+	/*mmf_return_val_if_fail(err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);*/
 
 	attrs = MMF_CAMCORDER_ATTRS(handle);
-	mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
+	mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
 	ret = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, var_args);
 
@@ -1723,8 +1721,8 @@ _mmcamcorder_set_attributes(MMHandleType handle, char **err_attr_name, const cha
 	int ret = MM_ERROR_NONE;
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 
-	mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
-//	mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
+	mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+	/*mmf_return_val_if_fail(err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);*/
 
 	if (!_MMCAMCORDER_TRYLOCK_CMD(handle)) {
 		_mmcam_dbg_err("Another command is running.");
@@ -1733,7 +1731,7 @@ _mmcamcorder_set_attributes(MMHandleType handle, char **err_attr_name, const cha
 
 	attrs = MMF_CAMCORDER_ATTRS(handle);
 	if (attrs) {
-		ret = __mmcamcorder_check_valid_pair( handle, err_attr_name, attribute_name, var_args );
+		ret = __mmcamcorder_check_valid_pair(handle, err_attr_name, attribute_name, var_args);
 	} else {
 		_mmcam_dbg_err("handle 0x%x, attrs is NULL, attr name [%s]", handle, attribute_name);
 		ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
@@ -1767,48 +1765,46 @@ _mmcamcorder_get_attribute_info(MMHandleType handle, const char *attr_name, MMCa
 	MMAttrsInfo attrinfo;
 	int ret = MM_ERROR_NONE;
 
-	mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
-	mmf_return_val_if_fail( attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
-	mmf_return_val_if_fail( info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
+	mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+	mmf_return_val_if_fail(attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+	mmf_return_val_if_fail(info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 
 	attrs = MMF_CAMCORDER_ATTRS(handle);
-	mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+	mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 
 	ret = mm_attrs_get_info_by_name(attrs, attr_name, (MMAttrsInfo*)&attrinfo);
 
-	if (ret == MM_ERROR_NONE)
-	{
+	if (ret == MM_ERROR_NONE) {
 		memset(info, 0x00, sizeof(MMCamAttrsInfo));
 		info->type = attrinfo.type;
 		info->flag = attrinfo.flag;
-		info->validity_type= attrinfo.validity_type;
+		info->validity_type = attrinfo.validity_type;
 
-		switch(attrinfo.validity_type)
-		{
-			case MM_ATTRS_VALID_TYPE_INT_ARRAY:
-				info->int_array.array = attrinfo.int_array.array;
-				info->int_array.count = attrinfo.int_array.count;
-				info->int_array.def = attrinfo.int_array.dval;
+		switch (attrinfo.validity_type) {
+		case MM_ATTRS_VALID_TYPE_INT_ARRAY:
+			info->int_array.array = attrinfo.int_array.array;
+			info->int_array.count = attrinfo.int_array.count;
+			info->int_array.def = attrinfo.int_array.dval;
 			break;
-			case MM_ATTRS_VALID_TYPE_INT_RANGE:
-				info->int_range.min = attrinfo.int_range.min;
-				info->int_range.max = attrinfo.int_range.max;
-				info->int_range.def = attrinfo.int_range.dval;
+		case MM_ATTRS_VALID_TYPE_INT_RANGE:
+			info->int_range.min = attrinfo.int_range.min;
+			info->int_range.max = attrinfo.int_range.max;
+			info->int_range.def = attrinfo.int_range.dval;
 			break;
-			case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
-				info->double_array.array = attrinfo.double_array.array;
-				info->double_array.count = attrinfo.double_array.count;
-				info->double_array.def = attrinfo.double_array.dval;
+		case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
+			info->double_array.array = attrinfo.double_array.array;
+			info->double_array.count = attrinfo.double_array.count;
+			info->double_array.def = attrinfo.double_array.dval;
 			break;
-			case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
-				info->double_range.min = attrinfo.double_range.min;
-				info->double_range.max = attrinfo.double_range.max;
-				info->double_range.def = attrinfo.double_range.dval;
+		case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
+			info->double_range.min = attrinfo.double_range.min;
+			info->double_range.max = attrinfo.double_range.max;
+			info->double_range.def = attrinfo.double_range.dval;
 			break;
-			case MM_ATTRS_VALID_TYPE_NONE:
+		case MM_ATTRS_VALID_TYPE_NONE:
 			break;
-			case MM_ATTRS_VALID_TYPE_INVALID:
-			default:
+		case MM_ATTRS_VALID_TYPE_INVALID:
+		default:
 			break;
 		}
 	}
@@ -1818,7 +1814,7 @@ _mmcamcorder_get_attribute_info(MMHandleType handle, const char *attr_name, MMCa
 
 
 bool
-_mmcamcorder_commit_camcorder_attrs (int attr_idx, const char *attr_name, const mmf_value_t *value, void *commit_param)
+_mmcamcorder_commit_camcorder_attrs(int attr_idx, const char *attr_name, const mmf_value_t *value, void *commit_param)
 {
 	bool bret = FALSE;
 	mmf_camcorder_t *hcamcorder = NULL;
@@ -1830,11 +1826,10 @@ _mmcamcorder_commit_camcorder_attrs (int attr_idx, const char *attr_name, const
 
 	hcamcorder = MMF_CAMCORDER(commit_param);
 
-	if (hcamcorder->cam_attrs_const_info[attr_idx].attr_commit) {
+	if (hcamcorder->cam_attrs_const_info[attr_idx].attr_commit)
 		bret = hcamcorder->cam_attrs_const_info[attr_idx].attr_commit((MMHandleType)commit_param, attr_idx, value);
-	} else {
+	else
 		bret = TRUE;
-	}
 
 	return bret;
 }
@@ -1927,7 +1922,7 @@ int __mmcamcorder_release_conf_valid_info(MMHandleType handle)
 }
 
 
-bool _mmcamcorder_commit_capture_width (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_capture_width(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	MMHandleType attr = 0;
 	int current_state = MM_CAMCORDER_STATE_NONE;
@@ -1962,7 +1957,7 @@ bool _mmcamcorder_commit_capture_width (MMHandleType handle, int attr_idx, const
 }
 
 
-bool _mmcamcorder_commit_capture_height (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_capture_height(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	int current_state = MM_CAMCORDER_STATE_NONE;
 
@@ -1983,9 +1978,9 @@ bool _mmcamcorder_commit_capture_height (MMHandleType handle, int attr_idx, cons
 }
 
 
-bool _mmcamcorder_commit_capture_break_cont_shot (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_capture_break_cont_shot(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
-	int current_state = _mmcamcorder_get_state( handle);
+	int current_state = _mmcamcorder_get_state(handle);
 	int ivalue = value->value.i_val;
 
 	mmf_camcorder_t        *hcamcorder = MMF_CAMCORDER(handle);
@@ -1996,9 +1991,9 @@ bool _mmcamcorder_commit_capture_break_cont_shot (MMHandleType handle, int attr_
 	const char *videosrc_name = NULL;
 
 	_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-	                              CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
-	                              "VideosrcElement",
-	                              &VideosrcElement );
+		CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+		"VideosrcElement",
+		&VideosrcElement);
 	_mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
@@ -2019,7 +2014,7 @@ bool _mmcamcorder_commit_capture_break_cont_shot (MMHandleType handle, int attr_
 			_mmcam_dbg_warn("cast CAMERA_CONTROL failed");
 		}
 	} else {
-		_mmcam_dbg_warn( "Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state );
+		_mmcam_dbg_warn("Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state);
 	}
 
 	return TRUE;
@@ -2039,7 +2034,7 @@ bool _mmcamcorder_commit_capture_count(MMHandleType handle, int attr_idx, const
 	mm_camcorder_get_attributes(handle, NULL, MMCAM_MODE, &mode, NULL);
 
 	_mmcam_dbg_log("current state %d, mode %d, set count %d",
-	               current_state, mode, value->value.i_val);
+		current_state, mode, value->value.i_val);
 
 	if (mode != MM_CAMCORDER_MODE_AUDIO &&
 	    current_state != MM_CAMCORDER_STATE_CAPTURING) {
@@ -2071,20 +2066,19 @@ bool _mmcamcorder_commit_capture_sound_enable(MMHandleType handle, int attr_idx,
 }
 
 
-bool _mmcamcorder_commit_audio_volume (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_audio_volume(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	int current_state = MM_CAMCORDER_STATE_NONE;
 	_MMCamcorderSubContext *sc = NULL;
 	bool bret = FALSE;
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
-	current_state = _mmcamcorder_get_state( handle);
+	current_state = _mmcamcorder_get_state(handle);
 
-	if ((current_state == MM_CAMCORDER_STATE_RECORDING)||(current_state == MM_CAMCORDER_STATE_PAUSED)) {
+	if ((current_state == MM_CAMCORDER_STATE_RECORDING) || (current_state == MM_CAMCORDER_STATE_PAUSED)) {
 		double mslNewVal = 0;
 		mslNewVal = value->value.d_val;
 
@@ -2109,7 +2103,7 @@ bool _mmcamcorder_commit_audio_volume (MMHandleType handle, int attr_idx, const
 }
 
 
-bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_fps(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	MMCamAttrsInfo fps_info;
 	int resolution_width = 0;
@@ -2120,11 +2114,11 @@ bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mm
 	_mmcam_dbg_log("FPS(%d)", value->value.i_val);
 
 	ret = mm_camcorder_get_attributes(handle, NULL,
-					  MMCAM_CAMERA_WIDTH, &resolution_width,
-					  MMCAM_CAMERA_HEIGHT, &resolution_height,
-					  NULL);
+		MMCAM_CAMERA_WIDTH, &resolution_width,
+		MMCAM_CAMERA_HEIGHT, &resolution_height,
+		NULL);
 
-	if(ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE) {
 		_mmcam_dbg_err("FAILED : coult not get resolution values.");
 		return FALSE;
 	}
@@ -2136,9 +2130,8 @@ bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mm
 	}
 
 	for (i = 0 ; i < fps_info.int_array.count ; i++) {
-		if(value->value.i_val == fps_info.int_array.array[i]) {
+		if (value->value.i_val == fps_info.int_array.array[i])
 			return TRUE;
-		}
 	}
 
 	_mmcam_dbg_err("FAILED : %d is not supported FPS", value->value.i_val);
@@ -2163,16 +2156,14 @@ bool _mmcamcorder_commit_camera_recording_motion_rate(MMHandleType handle, int a
 	/* Verify recording motion rate */
 	if (value->value.d_val > 0.0) {
 		sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-		if (!sc) {
+		if (!sc)
 			return TRUE;
-		}
 
 		/* set is_slow flag */
-		if (value->value.d_val != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
+		if (value->value.d_val != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE)
 			sc->is_modified_rate = TRUE;
-		} else {
+		else
 			sc->is_modified_rate = FALSE;
-		}
 
 		_mmcam_dbg_log("Set slow motion rate %lf", value->value.d_val);
 		return TRUE;
@@ -2194,9 +2185,8 @@ bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const m
 	mmf_return_val_if_fail(hcamcorder, FALSE);
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	attr = MMF_CAMCORDER_ATTRS(handle);
 	mmf_return_val_if_fail(attr, FALSE);
@@ -2221,10 +2211,10 @@ bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const m
 			int codec_type = MM_IMAGE_CODEC_JPEG;
 
 			mm_camcorder_get_attributes(handle, NULL,
-			                            MMCAM_CAMERA_HEIGHT, &height,
-			                            MMCAM_CAMERA_FORMAT, &preview_format,
-			                            MMCAM_IMAGE_ENCODER, &codec_type,
-			                            NULL);
+				MMCAM_CAMERA_HEIGHT, &height,
+				MMCAM_CAMERA_FORMAT, &preview_format,
+				MMCAM_IMAGE_ENCODER, &codec_type,
+				NULL);
 
 			if (current_state == MM_CAMCORDER_STATE_PREPARE) {
 				if (hcamcorder->resolution_changed == FALSE) {
@@ -2291,9 +2281,8 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const
 	mmf_return_val_if_fail(hcamcorder, FALSE);
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	attr = MMF_CAMCORDER_ATTRS(hcamcorder);
 	mmf_return_val_if_fail(attr, FALSE);
@@ -2312,11 +2301,11 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const
 		int video_stabilization = 0;
 
 		mm_camcorder_get_attributes(handle, NULL,
-		                            MMCAM_CAMERA_WIDTH, &width,
-		                            MMCAM_CAMERA_FORMAT, &preview_format,
-		                            MMCAM_IMAGE_ENCODER, &codec_type,
-		                            MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
-		                            NULL);
+			MMCAM_CAMERA_WIDTH, &width,
+			MMCAM_CAMERA_FORMAT, &preview_format,
+			MMCAM_IMAGE_ENCODER, &codec_type,
+			MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
+			NULL);
 
 		sc->info_video->preview_width = width;
 		sc->info_video->preview_height = height;
@@ -2388,13 +2377,13 @@ bool _mmcamcorder_commit_video_size(MMHandleType handle, int attr_idx, const mmf
 		return FALSE;
 	} else {
 		_mmcam_dbg_warn("Video Resolution %d [attr_idx %d] ",
-		                value->value.i_val, attr_idx);
+			value->value.i_val, attr_idx);
 		return TRUE;
 	}
 }
 
 
-bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_zoom(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	_MMCamcorderSubContext *sc = NULL;
 	int current_state = MM_CAMCORDER_STATE_NONE;
@@ -2403,9 +2392,8 @@ bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const m
 	int zoom_type;
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	_mmcam_dbg_log("(%d)", attr_idx);
 
@@ -2418,11 +2406,10 @@ bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const m
 		return FALSE;
 	}
 
-	if (attr_idx == MM_CAM_CAMERA_OPTICAL_ZOOM) {
+	if (attr_idx == MM_CAM_CAMERA_OPTICAL_ZOOM)
 		zoom_type = GST_CAMERA_CONTROL_OPTICAL_ZOOM;
-	} else {
+	else
 		zoom_type = GST_CAMERA_CONTROL_DIGITAL_ZOOM;
-	}
 
 	if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
 		int ret = FALSE;
@@ -2432,7 +2419,7 @@ bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const m
 			return TRUE;
 		}
 
-		control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+		control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
 		if (control == NULL) {
 			_mmcam_dbg_err("cast CAMERA_CONTROL failed");
 			return FALSE;
@@ -2642,7 +2629,7 @@ bool _mmcamcorder_commit_camera_tilt(MMHandleType handle, int attr_idx, const mm
 }
 
 
-bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_focus_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	MMHandleType attr = 0;
 	int current_state = MM_CAMCORDER_STATE_NONE;
@@ -2683,14 +2670,14 @@ bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, c
 			return TRUE;
 		}
 
-		control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+		control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
 		if (control == NULL) {
 			_mmcam_dbg_err("cast CAMERA_CONTROL failed");
 			return FALSE;
 		}
 
 		mslVal = value->value.i_val;
-		set_focus_mode = _mmcamcorder_convert_msl_to_sensor( handle, attr_idx, mslVal );
+		set_focus_mode = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal);
 
 		mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_SCAN_RANGE, &info);
 		flags = info.flag;
@@ -2720,7 +2707,7 @@ bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, c
 }
 
 
-bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_af_scan_range(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	_MMCamcorderSubContext *sc = NULL;
 	GstCameraControl *control = NULL;
@@ -2759,25 +2746,25 @@ bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx
 			return TRUE;
 		}
 
-		control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+		control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
 		if (control == NULL) {
 			_mmcam_dbg_err("cast CAMERA_CONTROL failed");
 			return FALSE;
 		}
 
 		mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FOCUS_MODE, &msl_mode, NULL);
-		converted_mode = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_CAMERA_FOCUS_MODE, msl_mode );
+		converted_mode = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_FOCUS_MODE, msl_mode);
 
 		if (gst_camera_control_get_focus(control, &cur_focus_mode, &cur_focus_range)) {
 			if ((newVal != cur_focus_range) || (converted_mode != cur_focus_mode)) {
 				if (gst_camera_control_set_focus(control, converted_mode, newVal)) {
-					//_mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);
+					/*_mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);*/
 					return TRUE;
 				} else {
 					_mmcam_dbg_warn("Failed to set AF mode[%d]", mslVal);
 				}
 			} else {
-				//_mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);
+				/*_mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);*/
 				return TRUE;
 			}
 		} else {
@@ -2791,7 +2778,7 @@ bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx
 }
 
 
-bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_af_touch_area(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	_MMCamcorderSubContext *sc = NULL;
 	GstCameraControl *control = NULL;
@@ -2809,9 +2796,8 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx
 	MMCamAttrsInfo info_h;
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	_mmcam_dbg_log("(%d)", attr_idx);
 
@@ -2822,8 +2808,8 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx
 	}
 
 	ret = mm_camcorder_get_attributes(handle, NULL,
-					  MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
-					  NULL);
+		MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
+		NULL);
 	if (ret != MM_ERROR_NONE) {
 		_mmcam_dbg_warn("Failed to get FOCUS MODE.[%x]", ret);
 		return FALSE;
@@ -2852,10 +2838,10 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx
 			if (!((info_y.flag|info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) {
 				set_area.x = value->value.i_val;
 				mm_camcorder_get_attributes(handle, NULL,
-							    MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
-							    MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
-							    MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
-							    NULL);
+					MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
+					MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
+					MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
+					NULL);
 				do_set = TRUE;
 			} else {
 				_mmcam_dbg_log("Just store AF area[x:%d]", value->value.i_val);
@@ -2868,13 +2854,13 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx
 			if (!((info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) {
 				set_area.y = value->value.i_val;
 				mm_camcorder_get_attributes(handle, NULL,
-							    MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
-							    MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
-							    MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
-							    NULL);
+					MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
+					MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
+					MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
+					NULL);
 				do_set = TRUE;
 			} else {
-				_mmcam_dbg_log( "Just store AF area[y:%d]", value->value.i_val );
+				_mmcam_dbg_log("Just store AF area[y:%d]", value->value.i_val);
 				return TRUE;
 			}
 			break;
@@ -2883,10 +2869,10 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx
 			if (!(info_h.flag & MM_ATTRS_FLAG_MODIFIED)) {
 				set_area.width = value->value.i_val;
 				mm_camcorder_get_attributes(handle, NULL,
-							    MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
-							    MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
-							    MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
-							    NULL);
+					MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
+					MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
+					MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
+					NULL);
 				do_set = TRUE;
 			} else {
 				_mmcam_dbg_log("Just store AF area[width:%d]", value->value.i_val);
@@ -2896,10 +2882,10 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx
 		case MM_CAM_CAMERA_AF_TOUCH_HEIGHT:
 			set_area.height = value->value.i_val;
 			mm_camcorder_get_attributes(handle, NULL,
-						    MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
-						    MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
-						    MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
-						    NULL);
+				MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
+				MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
+				MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
+				NULL);
 			do_set = TRUE;
 			break;
 		default:
@@ -2914,7 +2900,7 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx
 				return FALSE;
 			}
 
-			control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+			control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
 			if (control == NULL) {
 				_mmcam_dbg_err("cast CAMERA_CONTROL failed");
 				return FALSE;
@@ -2931,49 +2917,48 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx
 					ratio_height = (float)info->video_height / (float)info->preview_height;
 
 					_mmcam_dbg_log("original area %d,%d,%dx%d, resolution ratio : width %f, height %f",
-						       set_area.x, set_area.y, set_area.width, set_area.height, ratio_width, ratio_height);
+						set_area.x, set_area.y, set_area.width, set_area.height, ratio_width, ratio_height);
 
 					set_area.x = (int)((float)set_area.x * ratio_width);
 					set_area.y = (int)((float)set_area.y * ratio_height);
 					set_area.width = (int)((float)set_area.width * ratio_width);
 					set_area.height = (int)((float)set_area.height * ratio_height);
 
-					if (set_area.width <= 0) {
+					if (set_area.width <= 0)
 						set_area.width = 1;
-					}
-					if (set_area.height <= 0) {
+
+					if (set_area.height <= 0)
 						set_area.height = 1;
-					}
 
 					_mmcam_dbg_log("converted area %d,%d,%dx%d",
-						       set_area.x, set_area.y, set_area.width, set_area.height);
+						set_area.x, set_area.y, set_area.width, set_area.height);
 				} else {
 					_mmcam_dbg_warn("invalid preview size %dx%d, skip AF area converting",
-							info->preview_width, info->preview_height);
+						info->preview_width, info->preview_height);
 				}
 			}
 
 			ret = gst_camera_control_get_auto_focus_area(control, &get_area);
 			if (!ret) {
-				_mmcam_dbg_warn( "Failed to get AF area" );
+				_mmcam_dbg_warn("Failed to get AF area");
 				return FALSE;
 			}
 
 			/* width and height are not supported now */
 			if (get_area.x == set_area.x && get_area.y == set_area.y) {
 				_mmcam_dbg_log("No need to set AF area[x,y:%d,%d]",
-					       get_area.x, get_area.y);
+					get_area.x, get_area.y);
 				return TRUE;
 			}
 
 			ret = gst_camera_control_set_auto_focus_area(control, set_area);
 			if (ret) {
 				_mmcam_dbg_log("Succeed to set AF area[%d,%d,%dx%d]",
-					       set_area.x, set_area.y, set_area.width, set_area.height);
+					set_area.x, set_area.y, set_area.width, set_area.height);
 				return TRUE;
 			} else {
 				_mmcam_dbg_warn("Failed to set AF area[%d,%d,%dx%d]",
-						set_area.x, set_area.y, set_area.width, set_area.height);
+					set_area.x, set_area.y, set_area.width, set_area.height);
 			}
 		}
 	} else {
@@ -2984,7 +2969,7 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx
 }
 
 
-bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_capture_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	GstCameraControl *control = NULL;
 	int ivalue = value->value.i_val;
@@ -3007,19 +2992,18 @@ bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx,
 		return TRUE;
 	}
 
-	current_state = _mmcamcorder_get_state( handle);
-	if (current_state < MM_CAMCORDER_STATE_READY) {
+	current_state = _mmcamcorder_get_state(handle);
+	if (current_state < MM_CAMCORDER_STATE_READY)
 		return TRUE;
-	}
 
 	if (attr_idx == MM_CAM_CAMERA_F_NUMBER) {
 		exposure_type = GST_CAMERA_CONTROL_F_NUMBER;
-		mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
-		mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
+		mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue);
+		mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue);
 	} else if (attr_idx == MM_CAM_CAMERA_SHUTTER_SPEED) {
 		exposure_type = GST_CAMERA_CONTROL_SHUTTER_SPEED;
-		mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
-		mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
+		mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue);
+		mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue);
 	} else if (attr_idx == MM_CAM_CAMERA_ISO) {
 		exposure_type = GST_CAMERA_CONTROL_ISO;
 		mslVal1 = ivalue;
@@ -3032,8 +3016,8 @@ bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx,
 		check_scene_mode = TRUE;
 	} else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_VALUE) {
 		exposure_type = GST_CAMERA_CONTROL_EXPOSURE_VALUE;
-		mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
-		mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
+		mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue);
+		mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue);
 	}
 
 	if (check_scene_mode) {
@@ -3052,7 +3036,7 @@ bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx,
 			return TRUE;
 		}
 
-		control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+		control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
 		if (control == NULL) {
 			_mmcam_dbg_err("cast CAMERA_CONTROL failed");
 			return FALSE;
@@ -3060,10 +3044,10 @@ bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx,
 
 		ret = gst_camera_control_set_exposure(control, exposure_type, newVal1, newVal2);
 		if (ret) {
-			_mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
+			_mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2);
 			return TRUE;
 		} else {
-			_mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
+			_mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2);
 		}
 	} else {
 		_mmcam_dbg_log("pointer of video src is null");
@@ -3073,7 +3057,7 @@ bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx,
 }
 
 
-bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_wdr(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	GstCameraControl *control = NULL;
 	int mslVal = 0;
@@ -3091,12 +3075,11 @@ bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mm
 	}
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	/* check current state */
-	current_state = _mmcamcorder_get_state( handle);
+	current_state = _mmcamcorder_get_state(handle);
 	if (current_state < MM_CAMCORDER_STATE_READY) {
 		_mmcam_dbg_log("will be applied when preview starts");
 		return TRUE;
@@ -3123,17 +3106,17 @@ bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mm
 		if (gst_camera_control_get_wdr(control, &cur_value)) {
 			if (newVal != cur_value) {
 				if (gst_camera_control_set_wdr(control, newVal)) {
-					_mmcam_dbg_log( "Success - set wdr[%d]", mslVal );
+					_mmcam_dbg_log("Success - set wdr[%d]", mslVal);
 					return TRUE;
 				} else {
 					_mmcam_dbg_warn("Failed to set WDR. NewVal[%d],CurVal[%d]", newVal, cur_value);
 				}
 			} else {
-				_mmcam_dbg_log( "No need to set new WDR. Current[%d]", mslVal );
+				_mmcam_dbg_log("No need to set new WDR. Current[%d]", mslVal);
 				return TRUE;
 			}
 		} else {
-			_mmcam_dbg_warn( "Failed to get WDR." );
+			_mmcam_dbg_warn("Failed to get WDR.");
 		}
 	} else {
 		_mmcam_dbg_log("pointer of video src is null");
@@ -3243,9 +3226,8 @@ bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, cons
 	int size = 0;
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	/* get string */
 	filename = mmf_value_get_string(value, &size);
@@ -3277,7 +3259,7 @@ bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, cons
 
 
 
-bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_filter(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	GstColorBalance *balance = NULL;
 	GstColorBalanceChannel *Colorchannel = NULL;
@@ -3370,9 +3352,8 @@ bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_va
 	}
 
 	newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslNewVal);
-	if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE) {
+	if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE)
 		return FALSE;
-	}
 
 	/*_mmcam_dbg_log("label(%s): MSL(%d)->Sensor(%d)", control_label, mslNewVal, newVal);*/
 
@@ -3395,10 +3376,10 @@ bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_va
 
 	for (item = controls ; item && item->data ; item = item->next) {
 		Colorchannel = item->data;
-		//_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);
+		/*_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);*/
 
 		if (!strcmp(Colorchannel->label, control_label)) {
-			gst_color_balance_set_value (balance, Colorchannel, newVal);
+			gst_color_balance_set_value(balance, Colorchannel, newVal);
 			_mmcam_dbg_log("Set complete - %s[msl:%d,real:%d]", Colorchannel->label, mslNewVal, newVal);
 			break;
 		}
@@ -3413,11 +3394,11 @@ bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_va
 }
 
 
-bool _mmcamcorder_commit_filter_scene_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_filter_scene_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	GstCameraControl *control = NULL;
 	int mslVal = value->value.i_val;
-	int newVal = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_FILTER_SCENE_MODE, mslVal );
+	int newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_FILTER_SCENE_MODE, mslVal);
 	_MMCamcorderSubContext *sc = NULL;
 	int current_state = MM_CAMCORDER_STATE_NONE;
 
@@ -3458,26 +3439,25 @@ bool _mmcamcorder_commit_filter_scene_mode (MMHandleType handle, int attr_idx, c
 			if (mslVal == MM_CAMCORDER_SCENE_MODE_NORMAL) {
 				unsigned int i = 0;
 				int attr_idxs[] = {
-					MM_CAM_CAMERA_ISO
-					, MM_CAM_FILTER_BRIGHTNESS
-					, MM_CAM_FILTER_WB
-					, MM_CAM_FILTER_SATURATION
-					, MM_CAM_FILTER_SHARPNESS
-					, MM_CAM_FILTER_COLOR_TONE
-					, MM_CAM_CAMERA_EXPOSURE_MODE
+					MM_CAM_CAMERA_ISO,
+					MM_CAM_FILTER_BRIGHTNESS,
+					MM_CAM_FILTER_WB,
+					MM_CAM_FILTER_SATURATION,
+					MM_CAM_FILTER_SHARPNESS,
+					MM_CAM_FILTER_COLOR_TONE,
+					MM_CAM_CAMERA_EXPOSURE_MODE
 				};
 				mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
 
 				for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) {
-					if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i])) {
+					if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i]))
 						mmf_attribute_set_modified(&(attr->items[attr_idxs[i]]));
-					}
 				}
 			}
 
 			return TRUE;
 		} else {
-			_mmcam_dbg_log( "Failed to set program mode[%d].", mslVal );
+			_mmcam_dbg_log("Failed to set program mode[%d].", mslVal);
 		}
 	} else {
 		_mmcam_dbg_warn("pointer of video src is null");
@@ -3487,17 +3467,16 @@ bool _mmcamcorder_commit_filter_scene_mode (MMHandleType handle, int attr_idx, c
 }
 
 
-bool _mmcamcorder_commit_filter_flip (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_filter_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	_mmcam_dbg_warn("Filter Flip(%d)", value->value.i_val);
 	return TRUE;
 }
 
 
-bool _mmcamcorder_commit_audio_input_route (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_audio_input_route(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	_mmcam_dbg_log("Commit : Do nothing. this attr will be removed soon.");
-
 	return TRUE;
 }
 
@@ -3554,12 +3533,10 @@ bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const
 
 		_mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
 
-		if (!strcmp(videosink_name, "xvimagesink") ||
-		    !strcmp(videosink_name, "ximagesink")) {
+		if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "ximagesink")) {
 			_mmcam_dbg_log("Commit : Set XID[%x]", *(int*)(p_handle));
 			gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int*)(p_handle));
-		} else if (!strcmp(videosink_name, "evasimagesink") ||
-			   !strcmp(videosink_name, "evaspixmapsink")) {
+		} else if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink")) {
 			_mmcam_dbg_log("Commit : Set evas object [%p]", p_handle);
 			MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "evas-object", p_handle);
 		} else if (!strcmp(videosink_name, "waylandsink")) {
@@ -3710,7 +3687,7 @@ bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, cons
 	}
 
 	if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink") ||
-	    !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) {
+		!strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) {
 		MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "visible", value->value.i_val);
 		_mmcam_dbg_log("Set visible [%d] done.", value->value.i_val);
 		return TRUE;
@@ -3721,7 +3698,7 @@ bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, cons
 }
 
 
-bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_display_geometry_method(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	int method = 0;
 	int current_state = MM_CAMCORDER_STATE_NONE;
@@ -3795,8 +3772,8 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m
 
 	/* check current method */
 	mm_camcorder_get_attributes(handle, NULL,
-	                            MMCAM_DISPLAY_GEOMETRY_METHOD, &method,
-	                            NULL);
+		MMCAM_DISPLAY_GEOMETRY_METHOD, &method,
+		NULL);
 	if (method != MM_DISPLAY_METHOD_CUSTOM_ROI) {
 		_mmcam_dbg_log("current method[%d] is not supported rect", method);
 		return FALSE;
@@ -3819,11 +3796,11 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m
 		MMCamAttrsInfo info;
 
 		mm_camcorder_get_attributes(handle, NULL,
-		                            MMCAM_DISPLAY_RECT_X, &rect_x,
-		                            MMCAM_DISPLAY_RECT_Y, &rect_y,
-		                            MMCAM_DISPLAY_RECT_WIDTH, &rect_width,
-		                            MMCAM_DISPLAY_RECT_HEIGHT, &rect_height,
-		                            NULL);
+			MMCAM_DISPLAY_RECT_X, &rect_x,
+			MMCAM_DISPLAY_RECT_Y, &rect_y,
+			MMCAM_DISPLAY_RECT_WIDTH, &rect_width,
+			MMCAM_DISPLAY_RECT_HEIGHT, &rect_height,
+			NULL);
 		switch (attr_idx) {
 		case MM_CAM_DISPLAY_RECT_X:
 			mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_Y, &info);
@@ -3872,11 +3849,11 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m
 				}
 			} else {
 			    g_object_set(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
-							"dst-roi-x", rect_x,
-							"dst-roi-y", rect_y,
-							"dst-roi-w", rect_width,
-							"dst-roi-h", rect_height,
-							NULL);
+					"dst-roi-x", rect_x,
+					"dst-roi-y", rect_y,
+					"dst-roi-w", rect_width,
+					"dst-roi-h", rect_height,
+					NULL);
 			}
 		}
 
@@ -3943,7 +3920,7 @@ bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_i
 	int do_scaling = 0;
 	const char *videosink_name = NULL;
 
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
 
 	mmf_return_val_if_fail(handle, FALSE);
@@ -3983,7 +3960,7 @@ bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_i
 }
 
 
-bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_strobe(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	bool bret = FALSE;
 	_MMCamcorderSubContext *sc = NULL;
@@ -4158,8 +4135,8 @@ bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, c
 
 		set_hdr_mode = value->value.i_val;
 		mm_camcorder_get_attributes(handle, NULL,
-		                            MMCAM_CAMERA_HDR_CAPTURE, &current_value,
-		                            NULL);
+			MMCAM_CAMERA_HDR_CAPTURE, &current_value,
+			NULL);
 
 		if (set_hdr_mode == current_value) {
 			_mmcam_dbg_log("same HDR value : %d, do nothing", set_hdr_mode);
@@ -4189,9 +4166,8 @@ bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, c
 			sc->info_image->hdr_capture_mode = set_hdr_mode;
 			_mmcam_dbg_log("set HDR mode : %d", set_hdr_mode);
 
-			if (current_state == MM_CAMCORDER_STATE_PREPARE) {
+			if (current_state == MM_CAMCORDER_STATE_PREPARE)
 				_mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
-			}
 		} else {
 			_mmcam_dbg_err("sc is NULL. can not set HDR capture");
 			return FALSE;
@@ -4218,14 +4194,13 @@ bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_val
 	}
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	/*_mmcam_dbg_log("Commit : detect attribute(%d)", attr_idx);*/
 
 	/* state check */
-	current_state = _mmcamcorder_get_state( handle);
+	current_state = _mmcamcorder_get_state(handle);
 	if (current_state < MM_CAMCORDER_STATE_READY) {
 		_mmcam_dbg_log("will be applied when preview starts");
 		return TRUE;
@@ -4277,11 +4252,11 @@ bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_val
 			} else {
 				if (!gst_camera_control_set_detect(control, detect_type, set_value)) {
 					_mmcam_dbg_warn("Set detect failed. Type[%d],value[%d]",
-					                detect_type, set_value);
+						detect_type, set_value);
 					bret = FALSE;
 				} else {
 					_mmcam_dbg_log("Set detect success. Type[%d],value[%d]",
-					               detect_type, set_value);
+						detect_type, set_value);
 					bret = TRUE;
 				}
 			}
@@ -4358,6 +4333,7 @@ bool _mmcamcorder_commit_encoded_preview_gop_interval(MMHandleType handle, int a
 bool _mmcamcorder_commit_pid_for_sound_focus(MMHandleType handle, int attr_idx, const mmf_value_t *value)
 {
 	int new_pid = 0;
+	int ret = 0;
 	int current_state = MM_CAMCORDER_STATE_NONE;
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 
@@ -4367,7 +4343,7 @@ bool _mmcamcorder_commit_pid_for_sound_focus(MMHandleType handle, int attr_idx,
 	}
 
 	/* state check */
-	current_state = _mmcamcorder_get_state( handle);
+	current_state = _mmcamcorder_get_state(handle);
 	if (current_state > MM_CAMCORDER_STATE_NULL) {
 		_mmcam_dbg_log("invalid state %d", current_state);
 		return FALSE;
@@ -4376,7 +4352,7 @@ bool _mmcamcorder_commit_pid_for_sound_focus(MMHandleType handle, int attr_idx,
 	new_pid = value->value.i_val;
 
 	_mmcam_dbg_log("Commit : pid %d, current sound_focus_register %d, sound_focus_id %d",
-	               new_pid, hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
+		new_pid, hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
 
 	/* unregister sound focus before set new one */
 	if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) {
@@ -4398,18 +4374,16 @@ bool _mmcamcorder_commit_pid_for_sound_focus(MMHandleType handle, int attr_idx,
 			return FALSE;
 		}
 
-		if (MM_ERROR_NONE != mm_sound_register_focus_for_session(hcamcorder->sound_focus_id,
-		                                                         new_pid,
-		                                                         "media",
-		                                                         _mmcamcorder_sound_focus_cb,
-		                                                         hcamcorder)) {
+		ret = mm_sound_register_focus_for_session(hcamcorder->sound_focus_id,
+			new_pid, "media", _mmcamcorder_sound_focus_cb, hcamcorder);
+		if (ret != MM_ERROR_NONE) {
 			_mmcam_dbg_err("mm_sound_register_focus failed");
 			hcamcorder->error_code = MM_ERROR_POLICY_BLOCKED;
 			return FALSE;
 		}
 
 		_mmcam_dbg_log("mm_sound_register_focus done - id %d, session type %d, flags 0x%x",
-			       hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags);
+			hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags);
 	} else {
 		_mmcam_dbg_log("no need to register sound focus");
 	}
@@ -4451,16 +4425,14 @@ bool _mmcamcorder_commit_sound_stream_info(MMHandleType handle, int attr_idx, co
 }
 
 
-static bool
-__mmcamcorder_attrs_is_supported(MMHandleType handle, int idx)
+static bool __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx)
 {
 	mmf_attrs_t *attr = (mmf_attrs_t*)handle;
 	int flag;
 
 	if (mm_attrs_get_flags(handle, idx, &flag) == MM_ERROR_NONE) {
-		if (flag == MM_ATTRS_FLAG_NONE) {
+		if (flag == MM_ATTRS_FLAG_NONE)
 			return FALSE;
-		}
 	} else {
 		return FALSE;
 	}
@@ -4468,50 +4440,47 @@ __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx)
 	if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_RANGE) {
 		int min, max;
 		mm_attrs_get_valid_range((MMHandleType)attr, idx, &min, &max);
-		if (max < min) {
+		if (max < min)
 			return FALSE;
-		}
 	} else if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_ARRAY) {
 		int count;
 		int *array;
 		mm_attrs_get_valid_array((MMHandleType)attr, idx, &count, &array);
-		if (count == 0) {
+		if (count == 0)
 			return FALSE;
-		}
 	}
 
 	return TRUE;
 }
 
 
-bool
-_mmcamcorder_set_attribute_to_camsensor(MMHandleType handle)
+bool _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle)
 {
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	mmf_attrs_t *attr = NULL;
 
 	int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
 
-	unsigned int i = 0 ;
+	unsigned int i = 0;
 	int ret = TRUE;
 	int attr_idxs_default[] = {
-		MM_CAM_CAMERA_DIGITAL_ZOOM
-		, MM_CAM_CAMERA_OPTICAL_ZOOM
-		, MM_CAM_CAMERA_WDR
-		, MM_CAM_FILTER_CONTRAST
-		, MM_CAM_FILTER_HUE
-		, MM_CAM_STROBE_MODE
-		, MM_CAM_DETECT_MODE
+		MM_CAM_CAMERA_DIGITAL_ZOOM,
+		MM_CAM_CAMERA_OPTICAL_ZOOM,
+		MM_CAM_CAMERA_WDR,
+		MM_CAM_FILTER_CONTRAST,
+		MM_CAM_FILTER_HUE,
+		MM_CAM_STROBE_MODE,
+		MM_CAM_DETECT_MODE
 	};
 
 	int attr_idxs_extra[] = {
-		MM_CAM_CAMERA_ISO
-		, MM_CAM_FILTER_BRIGHTNESS
-		, MM_CAM_FILTER_WB
-		, MM_CAM_FILTER_SATURATION
-		, MM_CAM_FILTER_SHARPNESS
-		, MM_CAM_FILTER_COLOR_TONE
-		, MM_CAM_CAMERA_EXPOSURE_MODE
+		MM_CAM_CAMERA_ISO,
+		MM_CAM_FILTER_BRIGHTNESS,
+		MM_CAM_FILTER_WB,
+		MM_CAM_FILTER_SATURATION,
+		MM_CAM_FILTER_SHARPNESS,
+		MM_CAM_FILTER_COLOR_TONE,
+		MM_CAM_CAMERA_EXPOSURE_MODE
 	};
 
 	mmf_return_val_if_fail(hcamcorder, FALSE);
@@ -4529,30 +4498,26 @@ _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle)
 		_mmcam_dbg_log("attribute count(%d)", attr->count);
 
 		for (i = 0 ; i < ARRAY_SIZE(attr_idxs_default) ; i++) {
-			if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_default[i])) {
+			if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_default[i]))
 				mmf_attribute_set_modified(&(attr->items[attr_idxs_default[i]]));
-			}
 		}
 
 		/* Set extra if scene mode is NORMAL */
 		if (scene_mode == MM_CAMCORDER_SCENE_MODE_NORMAL) {
 			for (i = 0 ; i < ARRAY_SIZE(attr_idxs_extra) ; i++) {
-				if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_extra[i])) {
+				if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_extra[i]))
 					mmf_attribute_set_modified(&(attr->items[attr_idxs_extra[i]]));
-				}
 			}
 		} else {
 			/* Set scene mode if scene mode is NOT NORMAL */
-			if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, MM_CAM_FILTER_SCENE_MODE)) {
+			if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, MM_CAM_FILTER_SCENE_MODE))
 				mmf_attribute_set_modified(&(attr->items[MM_CAM_FILTER_SCENE_MODE]));
-			}
 		}
 
-		if (mmf_attrs_commit((MMHandleType)attr) == -1) {
+		if (mmf_attrs_commit((MMHandleType)attr) == -1)
 			ret = FALSE;
-		} else {
+		else
 			ret = TRUE;
-		}
 	}
 
 	_mmcam_dbg_log("Done.");
@@ -4563,11 +4528,11 @@ _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle)
 
 int _mmcamcorder_lock_readonly_attributes(MMHandleType handle)
 {
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	int table_size = 0;
 	int i = 0;
 	mmf_attrs_t *attr = NULL;
-	int nerror = MM_ERROR_NONE ;
+	int nerror = MM_ERROR_NONE;
 
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 
@@ -4578,8 +4543,7 @@ int _mmcamcorder_lock_readonly_attributes(MMHandleType handle)
 
 	table_size = ARRAY_SIZE(readonly_attributes);
 	_mmcam_dbg_log("%d", table_size);
-	for (i = 0; i < table_size; i++)
-	{
+	for (i = 0; i < table_size; i++) {
 		int sCategory = readonly_attributes[i];
 
 		mmf_attribute_set_readonly(&(attr->items[sCategory]));
@@ -4591,8 +4555,7 @@ int _mmcamcorder_lock_readonly_attributes(MMHandleType handle)
 
 int _mmcamcorder_set_disabled_attributes(MMHandleType handle)
 {
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
-	//int table_size = 0;
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	int i = 0;
 	mmf_attrs_t *attr = NULL;
 	type_string_array * disabled_attr = NULL;
@@ -4608,20 +4571,20 @@ int _mmcamcorder_set_disabled_attributes(MMHandleType handle)
 
 	/* add gst_param */
 	_mmcamcorder_conf_get_value_string_array(hcamcorder->conf_main,
-	                                         CONFIGURE_CATEGORY_MAIN_GENERAL,
-	                                         "DisabledAttributes",
-	                                         &disabled_attr);
+		CONFIGURE_CATEGORY_MAIN_GENERAL,
+		"DisabledAttributes",
+		&disabled_attr);
 	if (disabled_attr != NULL && disabled_attr->value) {
 		cnt_str = disabled_attr->count;
 		for (i = 0; i < cnt_str; i++) {
 			int idx = 0;
-			_mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i] );
+			_mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i]);
 			nerror = mm_attrs_get_index((MMHandleType)attr, disabled_attr->value[i], &idx);
-			if (nerror == MM_ERROR_NONE) {
+
+			if (nerror == MM_ERROR_NONE)
 				mmf_attribute_set_disabled(&(attr->items[idx]));
-			} else {
-				_mmcam_dbg_warn("No ATTR named %s[%d]",disabled_attr->value[i], i);
-			}
+			else
+				_mmcam_dbg_warn("No ATTR named %s[%d]", disabled_attr->value[i], i);
 		}
 	}
 
@@ -4641,9 +4604,8 @@ static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width,
 	mmf_return_val_if_fail(hcamcorder, FALSE);
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	current_state = _mmcamcorder_get_state(handle);
 
@@ -4690,15 +4652,14 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n
 
 	if (hcamcorder == NULL || attribute_name == NULL) {
 		_mmcam_dbg_warn("handle[%p] or attribute_name[%p] is NULL.",
-		                hcamcorder, attribute_name );
+			hcamcorder, attribute_name);
 		return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 	}
 
-	if (err_attr_name) {
+	if (err_attr_name)
 		*err_attr_name = NULL;
-	}
 
-	//_mmcam_dbg_log( "ENTER" );
+	/*_mmcam_dbg_log( "ENTER" );*/
 
 	attrs = MMF_CAMCORDER_ATTRS(handle);
 
@@ -4712,21 +4673,18 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n
 
 		/* attribute name check */
 		if ((ret = mm_attrs_get_index(attrs, name, &idx)) != MM_ERROR_NONE) {
-			if (err_attr_name) {
+			if (err_attr_name)
 				*err_attr_name = strdup(name);
-			}
 
-			if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY) {	//to avoid confusing
+			if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY)
 				return MM_ERROR_COMMON_ATTR_NOT_EXIST;
-			} else {
+			else
 				return ret;
-			}
 		}
 
 		/* type check */
-		if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE) {
+		if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE)
 			return ret;
-		}
 
 		switch (attr_type) {
 		case MM_ATTRS_TYPE_INT:
@@ -4741,13 +4699,11 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n
 						break;
 					}
 				}
-				if (matched) {
+				if (matched)
 					break;
-				}
 			}
-			if (matched == FALSE) {
+			if (matched == FALSE)
 				va_arg((var_args), int);
-			}
 			break;
 		}
 		case MM_ATTRS_TYPE_DOUBLE:
@@ -4764,9 +4720,9 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n
 		case MM_ATTRS_TYPE_INVALID:
 		default:
 			_mmcam_dbg_err("Not supported attribute type(%d, name:%s)", attr_type, name);
-			if (err_attr_name) {
+			if (err_attr_name)
 				*err_attr_name = strdup(name);
-			}
+
 			return  MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 		}
 
@@ -4795,14 +4751,14 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n
 
 			check_result = FALSE;
 
-			for( j = 0 ; j < attr_info_0.int_array.count ; j++ ) {
+			for (j = 0 ; j < attr_info_0.int_array.count ; j++) {
 				if (attr_info_0.int_array.array[j] == check_pair_value[i][0] &&
 				    attr_info_1.int_array.array[j] == check_pair_value[i][1]) {
 					/*
 					_mmcam_dbg_log("Valid Pair[%s,%s] existed %dx%d[index:%d]",
-					               check_pair_name[i][0], check_pair_name[i][1],
-					               check_pair_value[i][0], check_pair_value[i][1], i);
-								   */
+						check_pair_name[i][0], check_pair_name[i][1],
+						check_pair_value[i][0], check_pair_value[i][1], i);
+					*/
 					check_result = TRUE;
 					break;
 				}
@@ -4810,8 +4766,8 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n
 
 			if (check_result == FALSE) {
 				_mmcam_dbg_err("INVALID pair[%s,%s] %dx%d",
-				               check_pair_name[i][0], check_pair_name[i][1],
-				               check_pair_value[i][0], check_pair_value[i][1]);
+					check_pair_name[i][0], check_pair_name[i][1],
+					check_pair_value[i][0], check_pair_value[i][1]);
 				if (err_attr_name) {
 					*err_attr_name = err_name;
 				} else {
@@ -4829,9 +4785,9 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n
 				int current_height = 0;
 
 				mm_camcorder_get_attributes(handle, NULL,
-				                            MMCAM_CAMERA_WIDTH, &current_width,
-				                            MMCAM_CAMERA_HEIGHT, &current_height,
-				                            NULL);
+					MMCAM_CAMERA_WIDTH, &current_width,
+					MMCAM_CAMERA_HEIGHT, &current_height,
+					NULL);
 
 				if (current_width != check_pair_value[i][0] ||
 				    current_height != check_pair_value[i][1]) {
@@ -4874,33 +4830,29 @@ bool _mmcamcorder_check_supported_attribute(MMHandleType handle, int attr_index)
 		/*
 		_mmcam_dbg_log("int array count %d", info.int_array.count);
 		*/
-		if (info.int_array.count <= 1) {
+		if (info.int_array.count <= 1)
 			return FALSE;
-		}
 		break;
 	case MM_ATTRS_VALID_TYPE_INT_RANGE:
 		/*
 		_mmcam_dbg_log("int range min %d, max %d",info.int_range.min, info.int_range.max);
 		*/
-		if (info.int_range.min >= info.int_range.max) {
+		if (info.int_range.min >= info.int_range.max)
 			return FALSE;
-		}
 		break;
 	case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
 		/*
 		_mmcam_dbg_log("double array count %d", info.double_array.count);
 		*/
-		if (info.double_array.count <= 1) {
+		if (info.double_array.count <= 1)
 			return FALSE;
-		}
 		break;
 	case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
 		/*
 		_mmcam_dbg_log("double range min %lf, max %lf",info.int_range.min, info.int_range.max);
 		*/
-		if (info.double_range.min >= info.double_range.max) {
+		if (info.double_range.min >= info.double_range.max)
 			return FALSE;
-		}
 		break;
 	default:
 		_mmcam_dbg_warn("invalid type %d", info.validity_type);
diff --git a/src/mm_camcorder_audiorec.c b/src/mm_camcorder_audiorec.c
index db7c319..a9789f1 100644
--- a/src/mm_camcorder_audiorec.c
+++ b/src/mm_camcorder_audiorec.c
@@ -62,6 +62,8 @@ static gboolean __mmcamcorder_audio_add_metadata_info_m4a(MMHandleType handle);
 static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle)
 {
 	int err = MM_ERROR_NONE;
+	int ret = MM_ERROR_NONE;
+
 	const char *aenc_name = NULL;
 	const char *mux_name = NULL;
 
@@ -88,7 +90,7 @@ static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle)
 	_mmcam_dbg_log("");
 
 	mux_elem = _mmcamcorder_get_type_element(handle, MM_CAM_FILE_FORMAT);
-	err = _mmcamcorder_conf_get_value_element_name( mux_elem, &mux_name );
+	err = _mmcamcorder_conf_get_value_element_name(mux_elem, &mux_name);
 
 	if (!mux_name || !strcmp(mux_name, "wavenc")) {
 		/* IF MUX in not chosen then record in raw file */
@@ -103,16 +105,14 @@ static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle)
 	_MMCAMCORDER_PIPELINE_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE, "camcorder_pipeline", err);
 
 	err = _mmcamcorder_create_audiosrc_bin(handle);
-	if (err != MM_ERROR_NONE) {
+	if (err != MM_ERROR_NONE)
 		return err;
-	}
 
 	if (info->bMuxing) {
 		/* Muxing. can use encodebin. */
 		err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_AUDIO);
-		if (err != MM_ERROR_NONE) {
+		if (err != MM_ERROR_NONE)
 			return err;
-		}
 	} else {
 		/* without muxing. can't use encodebin. */
 		aenc_elem = _mmcamcorder_get_type_element(handle, MM_CAM_AUDIO_ENCODER);
@@ -131,9 +131,8 @@ static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle)
 
 		_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_AQUE, "queue",  NULL, element_list, err);
 
-		if (strcmp(aenc_name, "wavenc") != 0) {
+		if (strcmp(aenc_name, "wavenc") != 0)
 			_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_CONV, "audioconvert",  NULL, element_list, err);
-		}
 
 		_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_AENC, aenc_name, NULL, element_list, err);
 
@@ -144,46 +143,48 @@ static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle)
 	if (info->bMuxing) {
 		/* IF MUX is indicated create MUX */
 		gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
-		                 sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
-		                 sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
-		                 NULL);
+			sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
+			sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
+			NULL);
 
-		srcpad = gst_element_get_static_pad (sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
-		sinkpad = gst_element_get_static_pad (sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
+		srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
+		sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
 		_MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
 	} else {
 		/* IF MUX in not chosen then record in raw amr file */
 		if (!strcmp(aenc_name, "wavenc")) {
 			gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
-			                 sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
-			                 sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
-			                 sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
-			                 sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
-			                 NULL);
-
-			if (!_MM_GST_ELEMENT_LINK_MANY(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
-			                               sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
-			                               sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
-			                               sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
-			                               NULL)) {
+				sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
+				NULL);
+
+			ret = _MM_GST_ELEMENT_LINK_MANY(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
+				NULL);
+			if (!ret) {
 				err = MM_ERROR_CAMCORDER_GST_LINK;
 				goto pipeline_creation_error;
 			}
 		} else {
 			gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
-			                 sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
-			                 sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
-			                 sc->encode_element[_MMCAMCORDER_ENCSINK_CONV].gst,
-			                 sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
-			                 sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
-			                 NULL);
-
-			if (!_MM_GST_ELEMENT_LINK_MANY(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
-			                               sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
-			                               sc->encode_element[_MMCAMCORDER_ENCSINK_CONV].gst,
-			                               sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
-			                               sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
-			                               NULL)) {
+				sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_CONV].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
+				NULL);
+
+			ret = _MM_GST_ELEMENT_LINK_MANY(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_CONV].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
+				sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
+				NULL);
+			if (!ret) {
 				err = MM_ERROR_CAMCORDER_GST_LINK;
 				goto pipeline_creation_error;
 			}
@@ -193,13 +194,13 @@ static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle)
 	/* set data probe function */
 	srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, "src");
 	MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_AUDIOREC,
-	                             __mmcamcorder_audio_dataprobe_voicerecorder, hcamcorder);
+		__mmcamcorder_audio_dataprobe_voicerecorder, hcamcorder);
 	gst_object_unref(srcpad);
 	srcpad = NULL;
 
 	srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst, "src");
 	MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_AUDIOREC,
-	                             __mmcamcorder_audio_dataprobe_record, hcamcorder);
+		__mmcamcorder_audio_dataprobe_record, hcamcorder);
 	gst_object_unref(srcpad);
 	srcpad = NULL;
 
@@ -242,7 +243,7 @@ pipeline_creation_error:
 int
 _mmcamcorder_create_audio_pipeline(MMHandleType handle)
 {
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
 
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
@@ -297,7 +298,7 @@ _mmcamcorder_destroy_audio_pipeline(MMHandleType handle)
 			gst_element_release_request_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, reqpad);
 			gst_object_unref(reqpad);
 
-			if(GST_IS_ELEMENT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst) &&
+			if (GST_IS_ELEMENT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst) &&
 			   GST_OBJECT_REFCOUNT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst) > 1) {
 				gst_object_unref(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst);
 			}
@@ -328,7 +329,7 @@ _mmcamcorder_destroy_audio_pipeline(MMHandleType handle)
 
 void* _MMCamcorderStartHelperFunc(void *handle)
 {
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_mmcamcorder_set_state((MMHandleType)hcamcorder, hcamcorder->target_state);
 
 	return NULL;
@@ -336,7 +337,7 @@ void* _MMCamcorderStartHelperFunc(void *handle)
 
 void* _MMCamcorderStopHelperFunc(void *handle)
 {
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_mmcamcorder_set_state((MMHandleType)hcamcorder, hcamcorder->target_state);
 
 	return NULL;
@@ -384,18 +385,18 @@ _mmcamcorder_audio_command(MMHandleType handle, int command)
 			int filename_length = 0;
 			int root_directory_length = 0;
 
-			if(sc->pipeline_time) {
+			if (sc->pipeline_time)
 				gst_element_set_start_time(pipeline, sc->pipeline_time);
-			}
+
 			sc->pipeline_time = RESET_PAUSE_TIME;
 
 			ret = mm_camcorder_get_attributes(handle, &err_attr_name,
-			                                  MMCAM_TARGET_MAX_SIZE, &imax_size,
-			                                  MMCAM_TARGET_TIME_LIMIT, &imax_time,
-			                                  MMCAM_FILE_FORMAT, &(info->fileformat),
-			                                  MMCAM_TARGET_FILENAME, &temp_filename, &filename_length,
-			                                  MMCAM_ROOT_DIRECTORY, &hcamcorder->root_directory, &root_directory_length,
-			                                  NULL);
+				MMCAM_TARGET_MAX_SIZE, &imax_size,
+				MMCAM_TARGET_TIME_LIMIT, &imax_time,
+				MMCAM_FILE_FORMAT, &(info->fileformat),
+				MMCAM_TARGET_FILENAME, &temp_filename, &filename_length,
+				MMCAM_ROOT_DIRECTORY, &hcamcorder->root_directory, &root_directory_length,
+				NULL);
 			if (ret != MM_ERROR_NONE) {
 				_mmcam_dbg_warn("failed to get attribute. (%s:%x)", err_attr_name, ret);
 				SAFE_FREE(err_attr_name);
@@ -414,28 +415,26 @@ _mmcamcorder_audio_command(MMHandleType handle, int command)
 				goto _ERR_CAMCORDER_AUDIO_COMMAND;
 			}
 
-			_mmcam_dbg_log("Record start : set file name using attribute - %s\n ",info->filename);
+			_mmcam_dbg_log("Record start : set file name using attribute - %s\n ", info->filename);
 
 			MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", info->filename);
 
 			sc->ferror_send = FALSE;
 			sc->ferror_count = 0;
 			sc->bget_eos = FALSE;
-			info->filesize =0;
+			info->filesize = 0;
 
 			/* set max size */
-			if (imax_size <= 0) {
+			if (imax_size <= 0)
 				info->max_size = 0; /* do not check */
-			} else {
+			else
 				info->max_size = ((guint64)imax_size) << 10; /* to byte */
-			}
 
 			/* set max time */
-			if (imax_time <= 0) {
+			if (imax_time <= 0)
 				info->max_time = 0; /* do not check */
-			} else {
+			else
 				info->max_time = ((guint64)imax_time) * 1000; /* to millisecond */
-			}
 
 			/* TODO : check free space before recording start */
 			dir_name = g_path_get_dirname(info->filename);
@@ -449,11 +448,11 @@ _mmcamcorder_audio_command(MMHandleType handle, int command)
 					if (file_system_type == MSDOS_SUPER_MAGIC &&
 					    (info->max_size == 0 || info->max_size > FAT32_FILE_SYSTEM_MAX_SIZE)) {
 						_mmcam_dbg_warn("FAT32 and too large max[%"G_GUINT64_FORMAT"], set max as %"G_GUINT64_FORMAT,
-						                info->max_size, FAT32_FILE_SYSTEM_MAX_SIZE);
+							info->max_size, FAT32_FILE_SYSTEM_MAX_SIZE);
 						info->max_size = FAT32_FILE_SYSTEM_MAX_SIZE;
 					} else {
 						_mmcam_dbg_warn("file system 0x%x, max size %"G_GUINT64_FORMAT,
-						                file_system_type, info->max_size);
+										file_system_type, info->max_size);
 					}
 				} else {
 					_mmcam_dbg_warn("_mmcamcorder_get_file_system_type failed");
@@ -468,15 +467,15 @@ _mmcamcorder_audio_command(MMHandleType handle, int command)
 
 			if ((err == -1) || free_space <= (_MMCAMCORDER_AUDIO_MINIMUM_SPACE+(5*1024))) {
 				_mmcam_dbg_err("OUT of STORAGE [err:%d or free space [%" G_GUINT64_FORMAT "] is smaller than [%d]",
-				               err, free_space, (_MMCAMCORDER_AUDIO_MINIMUM_SPACE+(5*1024)));
+					err, free_space, (_MMCAMCORDER_AUDIO_MINIMUM_SPACE+(5*1024)));
 				return MM_ERROR_OUT_OF_STORAGE;
 			}
 		}
 
 		ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			goto _ERR_CAMCORDER_AUDIO_COMMAND;
-		}
+
 		break;
 
 	case _MMCamcorder_CMD_PAUSE:
@@ -494,19 +493,18 @@ _mmcamcorder_audio_command(MMHandleType handle, int command)
 				break;
 			} else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
 				_mmcam_dbg_err("Pause fail, wait 200 ms, but file size is %lld",
-				               info->filesize);
+					info->filesize);
 				return MM_ERROR_CAMCORDER_INVALID_CONDITION;
 			} else {
 				_mmcam_dbg_warn("Wait for enough audio frame, retry count[%d], file size is %lld",
-				                count, info->filesize);
+					count, info->filesize);
 			}
 			usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
 		}
 
 		ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PAUSED);
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			goto _ERR_CAMCORDER_AUDIO_COMMAND;
-		}
 
 		/* FIXME: consider delay. */
 		pipe_clock = gst_pipeline_get_clock(GST_PIPELINE(pipeline));
@@ -521,9 +519,8 @@ _mmcamcorder_audio_command(MMHandleType handle, int command)
 		}
 
 		ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			goto _ERR_CAMCORDER_AUDIO_COMMAND;
-		}
 
 		if (info->bMuxing) {
 			MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
@@ -568,7 +565,7 @@ _mmcamcorder_audio_command(MMHandleType handle, int command)
 				return MM_ERROR_CAMCORDER_INVALID_CONDITION;
 			} else {
 				_mmcam_dbg_warn("Waiting for enough audio frame, re-count[%d], file size is %lld",
-				                 count, info->filesize);
+					count, info->filesize);
 			}
 			usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
 		}
@@ -600,7 +597,7 @@ _mmcamcorder_audio_command(MMHandleType handle, int command)
 
 		/* wait until finishing EOS */
 		_mmcam_dbg_log("Start to wait EOS");
-		if ((ret =_mmcamcorder_get_eos_message(handle)) != MM_ERROR_NONE) {
+		if ((ret = _mmcamcorder_get_eos_message(handle)) != MM_ERROR_NONE) {
 			info->b_commiting = FALSE;
 			goto _ERR_CAMCORDER_AUDIO_COMMAND;
 		}
@@ -608,12 +605,12 @@ _mmcamcorder_audio_command(MMHandleType handle, int command)
 	}
 
 	case _MMCamcorder_CMD_PREVIEW_START:
-		//MM_CAMCORDER_START_CHANGE_STATE;
+		/*MM_CAMCORDER_START_CHANGE_STATE;*/
 		break;
 
 	case _MMCamcorder_CMD_PREVIEW_STOP:
-		//MM_CAMCORDER_STOP_CHANGE_STATE;
-		//void
+		/*MM_CAMCORDER_STOP_CHANGE_STATE;*/
+		/*void*/
 		break;
 
 	default:
@@ -628,7 +625,7 @@ _ERR_CAMCORDER_AUDIO_COMMAND:
 int _mmcamcorder_audio_handle_eos(MMHandleType handle)
 {
 	int err = MM_ERROR_NONE;
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
 	_MMCamcorderAudioInfo *info = NULL;
 	GstElement *pipeline = NULL;
@@ -648,9 +645,8 @@ int _mmcamcorder_audio_handle_eos(MMHandleType handle)
 	pipeline = sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst;
 
 	err = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
-	if (err != MM_ERROR_NONE) {
+	if (err != MM_ERROR_NONE)
 		_mmcam_dbg_warn("Failed:_MMCamcorder_CMD_COMMIT:GST_STATE_READY. err[%x]", err);
-	}
 
 	/* Send recording report message to application */
 	msg.id = MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED;
@@ -661,14 +657,13 @@ int _mmcamcorder_audio_handle_eos(MMHandleType handle)
 	}
 
 /* START TAG HERE */
-	// MM_AUDIO_CODEC_AAC + MM_FILE_FORMAT_MP4
-	if(info->fileformat == MM_FILE_FORMAT_3GP || info->fileformat == MM_FILE_FORMAT_MP4){
+	/* MM_AUDIO_CODEC_AAC + MM_FILE_FORMAT_MP4 */
+	if (info->fileformat == MM_FILE_FORMAT_3GP || info->fileformat == MM_FILE_FORMAT_MP4)
 		__mmcamcorder_audio_add_metadata_info_m4a(handle);
-	}
 /* END TAG HERE */
 
 	report->recording_filename = g_strdup(info->filename);
-	msg.param.data= report;
+	msg.param.data = report;
 
 	_mmcamcorder_send_message(handle, &msg);
 
@@ -715,37 +710,33 @@ __mmcamcorder_get_decibel(unsigned char* raw, int size, MMCamcorderAudioFormat f
 
 	if (format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE)
 		depthByte = 2;
-	else		//MM_CAMCORDER_AUDIO_FORMAT_PCM_U8
+	else		/*MM_CAMCORDER_AUDIO_FORMAT_PCM_U8*/
 		depthByte = 1;
 
-	for( ; i < size ; i += (depthByte<<1) )
-	{
-		if (depthByte == 1)
-		{
+	for ( ; i < size ; i += (depthByte<<1)) {
+		if (depthByte == 1) {
 			pcm8 = (char *)(raw + i);
-			square_sum += (*pcm8)*(*pcm8);
-		}
-		else		//2byte
-		{
+			square_sum += (*pcm8) * (*pcm8);
+		} else { /*2byte*/
 			pcm16 = (short*)(raw + i);
-			square_sum += (*pcm16)*(*pcm16);
+			square_sum += (*pcm16) * (*pcm16);
 		}
 
 		count++;
 	}
 
 	if (count > 0) {
-		rms = sqrt( (double)square_sum/(double)count );
-		if (depthByte == 1) {
-			db = 20 * log10( rms/MAX_AMPLITUDE_MEAN_08BIT );
-		} else {
-			db = 20 * log10( rms/MAX_AMPLITUDE_MEAN_16BIT );
-		}
+		rms = sqrt((double)square_sum/(double)count);
+
+		if (depthByte == 1)
+			db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_08BIT);
+		else
+			db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_16BIT);
 	}
 
 	/*
 	_mmcam_dbg_log("size[%d],depthByte[%d],count[%d],rms[%f],db[%f]",
-	               size, depthByte, count, rms, db);
+					size, depthByte, count, rms, db);
 	*/
 
 	return db;
@@ -771,10 +762,11 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_voicerecorder(GstPad *pad
 
 	/* Set volume to audio input */
 	err = mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_name,
-									MMCAM_AUDIO_VOLUME, &volume,
-									MMCAM_AUDIO_FORMAT, &format,
-									MMCAM_AUDIO_CHANNEL, &channel,
-									NULL);
+		MMCAM_AUDIO_VOLUME, &volume,
+		MMCAM_AUDIO_FORMAT, &format,
+		MMCAM_AUDIO_CHANNEL, &channel,
+		NULL);
+
 	if (err < 0) {
 		_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
 		SAFE_FREE(err_name);
@@ -783,9 +775,8 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_voicerecorder(GstPad *pad
 
 	gst_buffer_map(buffer, &mapinfo, GST_MAP_READWRITE);
 
-	if(volume == 0){
+	if (volume == 0)
 		memset(mapinfo.data, 0, mapinfo.size);
-	}
 
 	/* Get current volume level of real input stream */
 	curdcb = __mmcamcorder_get_decibel(mapinfo.data, mapinfo.size, format);
@@ -795,12 +786,10 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_voicerecorder(GstPad *pad
 	_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 
 	/* CALL audio stream callback */
-	if ((hcamcorder->astream_cb) && buffer && mapinfo.data && mapinfo.size > 0)
-	{
+	if ((hcamcorder->astream_cb) && buffer && mapinfo.data && mapinfo.size > 0) {
 		MMCamcorderAudioStreamDataType stream;
 
-		if (_mmcamcorder_get_state((MMHandleType)hcamcorder) < MM_CAMCORDER_STATE_PREPARE)
-		{
+		if (_mmcamcorder_get_state((MMHandleType)hcamcorder) < MM_CAMCORDER_STATE_PREPARE) {
 			_mmcam_dbg_warn("Not ready for stream callback");
 			gst_buffer_unmap(buffer, &mapinfo);
 			return GST_PAD_PROBE_OK;
@@ -808,24 +797,22 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_voicerecorder(GstPad *pad
 
 		/*
 		_mmcam_dbg_log("Call audio steramCb, data[%p], format[%d], channel[%d], length[%d], volume_dB[%f]",
-			       GST_BUFFER_DATA(buffer), format, channel, GST_BUFFER_SIZE(buffer), curdcb);
+			GST_BUFFER_DATA(buffer), format, channel, GST_BUFFER_SIZE(buffer), curdcb);
 		*/
 
 		stream.data = (void *)mapinfo.data;
 		stream.format = format;
 		stream.channel = channel;
 		stream.length = mapinfo.size;
-		stream.timestamp = (unsigned int)(GST_BUFFER_PTS(buffer)/1000000);	//nano -> msecond
+		stream.timestamp = (unsigned int)(GST_BUFFER_PTS(buffer)/1000000);	/* nano -> msecond */
 		stream.volume_dB = curdcb;
 
-		_MMCAMCORDER_LOCK_ASTREAM_CALLBACK( hcamcorder );
+		_MMCAMCORDER_LOCK_ASTREAM_CALLBACK(hcamcorder);
 
-		if(hcamcorder->astream_cb)
-		{
+		if (hcamcorder->astream_cb)
 			hcamcorder->astream_cb(&stream, hcamcorder->astream_cb_param);
-		}
 
-		_MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK( hcamcorder );
+		_MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK(hcamcorder);
 	}
 
 	gst_buffer_unmap(buffer, &mapinfo);
@@ -842,6 +829,7 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_record(GstPad *pad, GstPa
 	guint64 trailer_size = 0;
 	char *filename = NULL;
 	unsigned long long remained_time = 0;
+	int get_trailer_size = 0;
 
 	_MMCamcorderSubContext *sc = NULL;
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
@@ -858,18 +846,17 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_record(GstPad *pad, GstPa
 
 	if (sc->isMaxtimePausing || sc->isMaxsizePausing) {
 		_mmcam_dbg_warn("isMaxtimePausing[%d],isMaxsizePausing[%d]",
-		                sc->isMaxtimePausing, sc->isMaxsizePausing);
+			sc->isMaxtimePausing, sc->isMaxsizePausing);
 		return GST_PAD_PROBE_DROP;
 	}
 
 	buffer_size = gst_buffer_get_size(buffer);
 
 	if (audioinfo->filesize == 0) {
-		if (audioinfo->fileformat == MM_FILE_FORMAT_WAV) {
+		if (audioinfo->fileformat == MM_FILE_FORMAT_WAV)
 			audioinfo->filesize += 44; /* wave header size */
-		} else if (audioinfo->fileformat == MM_FILE_FORMAT_AMR) {
+		else if (audioinfo->fileformat == MM_FILE_FORMAT_AMR)
 			audioinfo->filesize += 6; /* amr header size */
-		}
 
 		audioinfo->filesize += buffer_size;
 		return GST_PAD_PROBE_OK;
@@ -881,9 +868,11 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_record(GstPad *pad, GstPa
 	}
 
 	/* get trailer size */
-	if (audioinfo->fileformat == MM_FILE_FORMAT_3GP ||
-			audioinfo->fileformat == MM_FILE_FORMAT_MP4 ||
-			audioinfo->fileformat == MM_FILE_FORMAT_AAC) {
+	get_trailer_size = (
+		audioinfo->fileformat == MM_FILE_FORMAT_3GP ||
+		audioinfo->fileformat == MM_FILE_FORMAT_MP4 ||
+		audioinfo->fileformat == MM_FILE_FORMAT_AAC) ? TRUE : FALSE;
+	if (get_trailer_size) {
 		MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
 		/*_mmcam_dbg_log("trailer_size %d", trailer_size);*/
 	} else {
@@ -916,11 +905,11 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_record(GstPad *pad, GstPa
 			if (sc->ferror_count == 2 && sc->ferror_send == FALSE) {
 				sc->ferror_send = TRUE;
 				msg.id = MM_MESSAGE_CAMCORDER_ERROR;
-				if (free_space_ret == -2) {
+				if (free_space_ret == -2)
 					msg.param.code = MM_ERROR_FILE_NOT_FOUND;
-				} else {
+				else
 					msg.param.code = MM_ERROR_FILE_READ;
-				}
+
 				_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 			} else {
 				sc->ferror_count++;
@@ -933,7 +922,7 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_record(GstPad *pad, GstPa
 			if (free_space < (guint64)(_MMCAMCORDER_AUDIO_MINIMUM_SPACE + buffer_size + trailer_size)) {
 				_mmcam_dbg_warn("No more space for recording!!!");
 				_mmcam_dbg_warn("Free Space : [%" G_GUINT64_FORMAT "], file size : [%" G_GUINT64_FORMAT "]",
-				                free_space, audioinfo->filesize);
+					free_space, audioinfo->filesize);
 
 				if (audioinfo->bMuxing) {
 					MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
@@ -975,7 +964,7 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_record(GstPad *pad, GstPa
 			audioinfo->max_size < audioinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE) {
 		_mmcam_dbg_warn("Max size!!! Recording is paused.");
 		_mmcam_dbg_warn("Max [%" G_GUINT64_FORMAT "], file [%" G_GUINT64_FORMAT "], trailer : [%" G_GUINT64_FORMAT "]", \
-				audioinfo->max_size, audioinfo->filesize, trailer_size);
+			audioinfo->max_size, audioinfo->filesize, trailer_size);
 
 		/* just same as pause status. After blocking two queue, this function will not call again. */
 		if (audioinfo->bMuxing) {
@@ -1003,7 +992,7 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_record(GstPad *pad, GstPa
 	/* check recording time limit and send recording status message */
 	if (audioinfo->max_time > 0 && rec_pipe_time > audioinfo->max_time) {
 		_mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
-		                rec_pipe_time, audioinfo->max_time);
+			rec_pipe_time, audioinfo->max_time);
 
 		if (audioinfo->bMuxing) {
 			MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
@@ -1045,13 +1034,13 @@ static gboolean __mmcamcorder_audio_add_metadata_info_m4a(MMHandleType handle)
 	gint64 current_pos = 0;
 	gint64 moov_pos = 0;
 	gint64 udta_pos = 0;
-	// supporting audio geo tag for mobile
+	/* supporting audio geo tag for mobile */
 	int gps_enable = 0;
 	gdouble longitude = 0;
 	gdouble latitude = 0;
 	gdouble altitude = 0;
-	_MMCamcorderLocationInfo geo_info = {0,0,0};
-	_MMCamcorderLocationInfo loc_info = {0,0,0};
+	_MMCamcorderLocationInfo geo_info = {0, 0, 0};
+	_MMCamcorderLocationInfo loc_info = {0, 0, 0};
 
 	char err_msg[128] = {'\0',};
 
@@ -1067,15 +1056,15 @@ static gboolean __mmcamcorder_audio_add_metadata_info_m4a(MMHandleType handle)
 
 	info = sc->info_audio;
 	mm_camcorder_get_attributes(handle, NULL,
-	                            MMCAM_TAG_GPS_ENABLE, &gps_enable,
-	                            NULL);
+		MMCAM_TAG_GPS_ENABLE, &gps_enable,
+		NULL);
 
 	if (gps_enable) {
 		mm_camcorder_get_attributes(handle, NULL,
-		                            MMCAM_TAG_LATITUDE, &latitude,
-		                            MMCAM_TAG_LONGITUDE, &longitude,
-		                            MMCAM_TAG_ALTITUDE, &altitude,
-		                            NULL);
+			MMCAM_TAG_LATITUDE, &latitude,
+			MMCAM_TAG_LONGITUDE, &longitude,
+			MMCAM_TAG_ALTITUDE, &altitude,
+			NULL);
 		loc_info.longitude = _mmcamcorder_double_to_fix(longitude);
 		loc_info.latitude = _mmcamcorder_double_to_fix(latitude);
 		loc_info.altitude = _mmcamcorder_double_to_fix(altitude);
@@ -1094,20 +1083,18 @@ static gboolean __mmcamcorder_audio_add_metadata_info_m4a(MMHandleType handle)
 	/* find udta container.
 	   if, there are udta container, write loci box after that
 	   else, make udta container and write loci box. */
-	if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('u','d','t','a'), TRUE)) {
+	if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('u', 'd', 't', 'a'), TRUE)) {
 		size_t nread = 0;
 
 		_mmcam_dbg_log("find udta container");
 
 		/* read size */
-		if (fseek(f, -8L, SEEK_CUR) != 0) {
+		if (fseek(f, -8L, SEEK_CUR) != 0)
 			goto fail;
-		}
 
 		udta_pos = ftello(f);
-		if (udta_pos < 0) {
+		if (udta_pos < 0)
 			goto ftell_fail;
-		}
 
 		nread = fread(&buf, sizeof(char), sizeof(buf), f);
 
@@ -1116,60 +1103,49 @@ static gboolean __mmcamcorder_audio_add_metadata_info_m4a(MMHandleType handle)
 		udta_size = _mmcamcorder_get_container_size(buf);
 
 		/* goto end of udta and write 'smta' box */
-		if (fseek(f, (udta_size-4L), SEEK_CUR) != 0) {
+		if (fseek(f, (udta_size-4L), SEEK_CUR) != 0)
 			goto fail;
-		}
 
 		if (gps_enable) {
-			if (!_mmcamcorder_write_loci(f, loc_info)) {
+			if (!_mmcamcorder_write_loci(f, loc_info))
 				goto fail;
-			}
 
-			if (!_mmcamcorder_write_geodata( f, geo_info )) {
+			if (!_mmcamcorder_write_geodata(f, geo_info))
 				goto fail;
-			}
 		}
 
 		current_pos = ftello(f);
-		if (current_pos < 0) {
+		if (current_pos < 0)
 			goto ftell_fail;
-		}
 
-		if (!_mmcamcorder_update_size(f, udta_pos, current_pos)) {
+		if (!_mmcamcorder_update_size(f, udta_pos, current_pos))
 			goto fail;
-		}
 	} else {
 		_mmcam_dbg_log("No udta container");
-		if (fseek(f, 0, SEEK_END) != 0) {
+		if (fseek(f, 0, SEEK_END) != 0)
 			goto fail;
-		}
 
-		if (!_mmcamcorder_write_udta(f, gps_enable, loc_info, geo_info)) {
+		if (!_mmcamcorder_write_udta(f, gps_enable, loc_info, geo_info))
 			goto fail;
-		}
 	}
 
 	/* find moov container.
 	   update moov container size. */
-	if((current_pos = ftello(f))<0)
+	if ((current_pos = ftello(f)) < 0)
 		goto ftell_fail;
 
-	if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('m','o','o','v'), TRUE)) {
+	if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('m', 'o', 'o', 'v'), TRUE)) {
 
 		_mmcam_dbg_log("found moov container");
-		if (fseek(f, -8L, SEEK_CUR) !=0) {
+		if (fseek(f, -8L, SEEK_CUR) != 0)
 			goto fail;
-		}
 
 		moov_pos = ftello(f);
-		if (moov_pos < 0) {
+		if (moov_pos < 0)
 			goto ftell_fail;
-		}
 
-		if (!_mmcamcorder_update_size(f, moov_pos, current_pos)) {
+		if (!_mmcamcorder_update_size(f, moov_pos, current_pos))
 			goto fail;
-		}
-
 
 	} else {
 		_mmcam_dbg_err("No 'moov' container");
diff --git a/src/mm_camcorder_configure.c b/src/mm_camcorder_configure.c
index 4334d4e..14feac1 100644
--- a/src/mm_camcorder_configure.c
+++ b/src/mm_camcorder_configure.c
@@ -65,17 +65,17 @@ void _mmcamcorder_conf_init(MMHandleType handle, int type, camera_conf** configu
 	};
 
 	/* Audiosrc element default value */
-	static type_int  ___audiosrc_default_channel = { "Channel", 1 };
-	static type_int  ___audiosrc_default_bitrate = { "BitRate", 8000 };
-	static type_int  ___audiosrc_default_depth = { "Depth", 16 };
-	static type_int  ___audiosrc_default_blocksize = { "BlockSize", 1280 };
+	static type_int  ___audiosrc_default_channel = {"Channel", 1};
+	static type_int  ___audiosrc_default_bitrate = {"BitRate", 8000};
+	static type_int  ___audiosrc_default_depth = {"Depth", 16};
+	static type_int  ___audiosrc_default_blocksize = {"BlockSize", 1280};
 	static type_int* __audiosrc_default_int_array[] = {
 		&___audiosrc_default_channel,
 		&___audiosrc_default_bitrate,
 		&___audiosrc_default_depth,
 		&___audiosrc_default_blocksize,
 	};
-	static type_string  ___audiosrc_default_device = { "Device", "default" };
+	static type_string  ___audiosrc_default_device = {"Device", "default"};
 	static type_string* __audiosrc_default_string_array[] = {
 		&___audiosrc_default_device,
 	};
@@ -83,28 +83,28 @@ void _mmcamcorder_conf_init(MMHandleType handle, int type, camera_conf** configu
 		"AudiosrcElement",
 		"audiotestsrc",
 		__audiosrc_default_int_array,
-		sizeof( __audiosrc_default_int_array ) / sizeof( type_int* ),
+		sizeof(__audiosrc_default_int_array) / sizeof(type_int*),
 		__audiosrc_default_string_array,
-		sizeof( __audiosrc_default_string_array ) / sizeof( type_string* ),
+		sizeof(__audiosrc_default_string_array) / sizeof(type_string*),
 	};
 
 	static type_element _audiomodemsrc_element_default = {
 		"AudiomodemsrcElement",
 		"audiotestsrc",
 		__audiosrc_default_int_array,
-		sizeof( __audiosrc_default_int_array ) / sizeof( type_int* ),
+		sizeof(__audiosrc_default_int_array) / sizeof(type_int*),
 		__audiosrc_default_string_array,
-		sizeof( __audiosrc_default_string_array ) / sizeof( type_string* ),
+		sizeof(__audiosrc_default_string_array) / sizeof(type_string*),
 	};
 
 
 	/* Videosink element default value */
-	static type_int  ___videosink_default_display_id = { "display-id", 3 };
-	static type_int  ___videosink_default_x = { "x", 0 };
-	static type_int  ___videosink_default_y = { "y", 0 };
-	static type_int  ___videosink_default_width = { "width", 800 };
-	static type_int  ___videosink_default_height = { "height", 480 };
-	static type_int  ___videosink_default_rotation = { "rotation", 1 };
+	static type_int  ___videosink_default_display_id = {"display-id", 3};
+	static type_int  ___videosink_default_x = {"x", 0};
+	static type_int  ___videosink_default_y = {"y", 0};
+	static type_int  ___videosink_default_width = {"width", 800};
+	static type_int  ___videosink_default_height = {"height", 480};
+	static type_int  ___videosink_default_rotation = {"rotation", 1};
 	static type_int* __videosink_default_int_array[] = {
 		&___videosink_default_display_id,
 		&___videosink_default_x,
@@ -113,46 +113,46 @@ void _mmcamcorder_conf_init(MMHandleType handle, int type, camera_conf** configu
 		&___videosink_default_height,
 		&___videosink_default_rotation,
 	};
-	static type_string* __videosink_default_string_array[] = { NULL };
+	static type_string* __videosink_default_string_array[] = {NULL};
 	static type_element _videosink_element_overlay_default = {
 		"VideosinkElementOverlay",
 		"waylandsink",
 		__videosink_default_int_array,
-		sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
+		sizeof(__videosink_default_int_array) / sizeof(type_int*),
 		__videosink_default_string_array,
-		sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
+		sizeof(__videosink_default_string_array) / sizeof(type_string*),
 	};
 	static type_element _videosink_element_evas_default = {
 		"VideosinkElementEvas",
 		"evasimagesink",
 		__videosink_default_int_array,
-		sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
+		sizeof(__videosink_default_int_array) / sizeof(type_int*),
 		__videosink_default_string_array,
-		sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
+		sizeof(__videosink_default_string_array) / sizeof(type_string*),
 	};
 	static type_element _videosink_element_gl_default = {
 		"VideosinkElementGL",
 		"glimagesink",
 		__videosink_default_int_array,
-		sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
+		sizeof(__videosink_default_int_array) / sizeof(type_int*),
 		__videosink_default_string_array,
-		sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
+		sizeof(__videosink_default_string_array) / sizeof(type_string*),
 	};
 	static type_element _videosink_element_remote_default = {
 		"VideosinkElementRemote",
 		"shmsink",
 		__videosink_default_int_array,
-		sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
+		sizeof(__videosink_default_int_array) / sizeof(type_int*),
 		__videosink_default_string_array,
-		sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
+		sizeof(__videosink_default_string_array) / sizeof(type_string*),
 	};
 	static type_element _videosink_element_null_default = {
 		"VideosinkElementNull",
 		"fakesink",
 		__videosink_default_int_array,
-		sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
+		sizeof(__videosink_default_int_array) / sizeof(type_int*),
 		__videosink_default_string_array,
-		sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
+		sizeof(__videosink_default_string_array) / sizeof(type_string*),
 	};
 
 	/* Videoscale element default value */
@@ -864,22 +864,21 @@ void _mmcamcorder_conf_init(MMHandleType handle, int type, camera_conf** configu
 		hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER] = conf_main_image_encoder_table;
 		hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_MUX]           = conf_main_mux_table;
 
-		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_GENERAL]       = sizeof( conf_main_general_table ) / info_table_size;
-		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT]   = sizeof( conf_main_video_input_table ) / info_table_size;
-		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT]   = sizeof( conf_main_audio_input_table ) / info_table_size;
-		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT]  = sizeof( conf_main_video_output_table ) / info_table_size;
-		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_CAPTURE]       = sizeof( conf_main_capture_table ) / info_table_size;
-		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_RECORD]        = sizeof( conf_main_record_table ) / info_table_size;
-		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER] = sizeof( conf_main_video_encoder_table ) / info_table_size;
-		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER] = sizeof( conf_main_audio_encoder_table ) / info_table_size;
-		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER] = sizeof( conf_main_image_encoder_table ) / info_table_size;
-		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_MUX]           = sizeof( conf_main_mux_table ) / info_table_size;
+		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_GENERAL]       = sizeof(conf_main_general_table) / info_table_size;
+		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT]   = sizeof(conf_main_video_input_table) / info_table_size;
+		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT]   = sizeof(conf_main_audio_input_table) / info_table_size;
+		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT]  = sizeof(conf_main_video_output_table) / info_table_size;
+		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_CAPTURE]       = sizeof(conf_main_capture_table) / info_table_size;
+		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_RECORD]        = sizeof(conf_main_record_table) / info_table_size;
+		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER] = sizeof(conf_main_video_encoder_table) / info_table_size;
+		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER] = sizeof(conf_main_audio_encoder_table) / info_table_size;
+		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER] = sizeof(conf_main_image_encoder_table) / info_table_size;
+		hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_MUX]           = sizeof(conf_main_mux_table) / info_table_size;
 
-		(*configure_info)->info = (conf_detail**)g_malloc0( sizeof( conf_detail* ) * CONFIGURE_CATEGORY_MAIN_NUM );
+		(*configure_info)->info = (conf_detail**)g_malloc0(sizeof(conf_detail*) * CONFIGURE_CATEGORY_MAIN_NUM);
 
-		for (i = 0 ; i < CONFIGURE_CATEGORY_MAIN_NUM ; i++) {
+		for (i = 0 ; i < CONFIGURE_CATEGORY_MAIN_NUM ; i++)
 			(*configure_info)->info[i] = NULL;
-		}
 	} else {
 		hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_CAMERA]     = conf_ctrl_camera_table;
 		hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_STROBE]     = conf_ctrl_strobe_table;
@@ -888,18 +887,17 @@ void _mmcamcorder_conf_init(MMHandleType handle, int type, camera_conf** configu
 		hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_CAPTURE]    = conf_ctrl_capture_table;
 		hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_DETECT]     = conf_ctrl_detect_table;
 
-		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_CAMERA]     = sizeof( conf_ctrl_camera_table ) / info_table_size;
-		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_STROBE]     = sizeof( conf_ctrl_strobe_table ) / info_table_size;
-		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_EFFECT]     = sizeof( conf_ctrl_effect_table ) / info_table_size;
-		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH] = sizeof( conf_ctrl_photograph_table ) / info_table_size;
-		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_CAPTURE]    = sizeof( conf_ctrl_capture_table ) / info_table_size;
-		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_DETECT]     = sizeof( conf_ctrl_detect_table ) / info_table_size;
+		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_CAMERA]     = sizeof(conf_ctrl_camera_table) / info_table_size;
+		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_STROBE]     = sizeof(conf_ctrl_strobe_table) / info_table_size;
+		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_EFFECT]     = sizeof(conf_ctrl_effect_table) / info_table_size;
+		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH] = sizeof(conf_ctrl_photograph_table) / info_table_size;
+		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_CAPTURE]    = sizeof(conf_ctrl_capture_table) / info_table_size;
+		hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_DETECT]     = sizeof(conf_ctrl_detect_table) / info_table_size;
 
-		(*configure_info)->info = (conf_detail**)g_malloc0( sizeof( conf_detail* ) * CONFIGURE_CATEGORY_CTRL_NUM );
+		(*configure_info)->info = (conf_detail**)g_malloc0(sizeof(conf_detail*) * CONFIGURE_CATEGORY_CTRL_NUM);
 
-		for (i = 0 ; i < CONFIGURE_CATEGORY_CTRL_NUM ; i++) {
+		for (i = 0 ; i < CONFIGURE_CATEGORY_CTRL_NUM ; i++)
 			(*configure_info)->info[i] = NULL;
-		}
 	}
 
 	_mmcam_dbg_log("Done.");
@@ -928,20 +926,18 @@ int _mmcamcorder_conf_get_info(MMHandleType handle, int type, const char *ConfFi
 		snprintf(conf_path, sizeof(conf_path), "%s/multimedia/%s", TZ_SYS_ETC, ConfFile);
 		_mmcam_dbg_log("Try open Configure File[%s]", conf_path);
 		fd = fopen(conf_path, "r");
-		if (fd == NULL) {
+		if (fd == NULL)
 			_mmcam_dbg_warn("open failed.[%s] errno [%d]", conf_path, errno);
-		}
 	}
 
 	if (fd != NULL) {
 		ret = _mmcamcorder_conf_parse_info(handle, type, fd, configure_info);
 		fclose(fd);
 	} else {
-		if (errno == ENOENT) {
+		if (errno == ENOENT)
 			ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
-		} else {
+		else
 			ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
-		}
 	}
 
 	_mmcam_dbg_log("Leave...");
@@ -972,7 +968,7 @@ int _mmcamcorder_conf_parse_info(MMHandleType handle, int type, FILE* fd, camera
 	char *detail_string = NULL;
 	char *user_ptr = NULL;
 
-	_mmcam_dbg_log( "" );
+	_mmcam_dbg_log("");
 
 	camera_conf* new_conf = (camera_conf *)g_malloc0(sizeof(camera_conf));
 	if (new_conf == NULL) {
@@ -1005,47 +1001,39 @@ int _mmcamcorder_conf_parse_info(MMHandleType handle, int type, FILE* fd, camera
 	read_main = 0;
 	count_main_category = 0;
 
-	while( !feof( fd ) )
-	{
-		if( read_main == 0 )
-		{
-			length_read = getline( &buffer_string, &BUFFER_LENGTH_STRING, fd );
+	while (!feof(fd)) {
+		if (read_main == 0) {
+			length_read = getline(&buffer_string, &BUFFER_LENGTH_STRING, fd);
 			/*_mmcam_dbg_log( "Read Line : [%s]", buffer_string );*/
 
 			count_token = 0;
-			token = strtok_r( buffer_string, delimiters, &user_ptr );
+			token = strtok_r(buffer_string, delimiters, &user_ptr);
 
-			if ((token) && (token[0] == ';') && (length_read > -1))
-			{
+			if ((token) && (token[0] == ';') && (length_read > -1)) {
 				/*_mmcam_dbg_log( "Comment - Nothing to do" );*/
 				continue;
 			}
 
-			while( token )
-			{
-				/*_mmcam_dbg_log( "token : [%s]", token );*/
+			while (token) {
+				/*_mmcam_dbg_log("token : [%s]", token);*/
 				buffer_token[count_token] = token;
 				count_token++;
-				token = strtok_r( NULL, delimiters, &user_ptr );
+				token = strtok_r(NULL, delimiters, &user_ptr);
 			}
 
-			if( count_token == 0 )
-			{
+			if (count_token == 0)
 				continue;
-			}
 		}
 
 		read_main = 0;
 
 		/* Comment */
-		if( *buffer_token[0] == ';' )
-		{
+		if (*buffer_token[0] == ';') {
 			/*_mmcam_dbg_log( "Comment - Nothing to do" );*/
 		}
 		/* Main Category */
-		else if( *buffer_token[0] == '[' )
-		{
-			category_name = get_new_string( buffer_token[0] );
+		else if (*buffer_token[0] == '[') {
+			category_name = get_new_string(buffer_token[0]);
 			if (category_name == NULL) {
 				_mmcam_dbg_err("strdup failed for [%s]", buffer_token[0]);
 				continue;
@@ -1054,39 +1042,33 @@ int _mmcamcorder_conf_parse_info(MMHandleType handle, int type, FILE* fd, camera
 			count_main_category++;
 			count_details = 0;
 
-			while( !feof( fd ) )
-			{
-				length_read = getline( &buffer_string, &BUFFER_LENGTH_STRING, fd );
-				/*_mmcam_dbg_log( "Read Detail Line : [%s], read length : [%d]", buffer_string, length_read );*/
+			while (!feof(fd)) {
+				length_read = getline(&buffer_string, &BUFFER_LENGTH_STRING, fd);
+				/*_mmcam_dbg_log("Read Detail Line : [%s], read length : [%d]", buffer_string, length_read);*/
 
-				detail_string = get_new_string( buffer_string );
+				detail_string = get_new_string(buffer_string);
 
-				token = strtok_r( buffer_string, delimiters, &user_ptr );
+				token = strtok_r(buffer_string, delimiters, &user_ptr);
 
-				if( token && token[0] != ';' && length_read > -1 )
-				{
-					/*_mmcam_dbg_log( "token : [%s]", token );*/
-					if( token[0] == '[' )
-					{
+				if (token && token[0] != ';' && length_read > -1) {
+					/*_mmcam_dbg_log("token : [%s]", token);*/
+					if (token[0] == '[') {
 						read_main = 1;
 						buffer_token[0] = token;
-						SAFE_G_FREE( detail_string );
+						SAFE_G_FREE(detail_string);
 						break;
 					}
 
 					buffer_details[count_details++] = detail_string;
-				}
-				else
-				{
-					SAFE_G_FREE( detail_string );
+				} else {
+					SAFE_G_FREE(detail_string);
 				}
 			}
 
-			/*_mmcam_dbg_log( "type : %d, category_name : %s, count : [%d]", type, category_name, count_details );*/
+			/*_mmcam_dbg_log("type : %d, category_name : %s, count : [%d]", type, category_name, count_details);*/
 
-			if( count_details == 0 )
-			{
-				_mmcam_dbg_warn( "category %s has no detail value... skip this category...", category_name );
+			if (count_details == 0) {
+				_mmcam_dbg_warn("category %s has no detail value... skip this category...", category_name);
 				SAFE_G_FREE(category_name);
 				continue;
 			}
@@ -1094,94 +1076,57 @@ int _mmcamcorder_conf_parse_info(MMHandleType handle, int type, FILE* fd, camera
 			category = -1;
 
 			/* Details */
-			if( type == CONFIGURE_TYPE_MAIN )
-			{
-				if( !strcmp( "[General]", category_name ) )
-				{
+			if (type == CONFIGURE_TYPE_MAIN) {
+				if (!strcmp("[General]", category_name)) {
 					category = CONFIGURE_CATEGORY_MAIN_GENERAL;
-				}
-				else if( !strcmp( "[VideoInput]", category_name ) )
-				{
+				} else if (!strcmp("[VideoInput]", category_name)) {
 					category = CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT;
-				}
-				else if( !strcmp( "[AudioInput]", category_name ) )
-				{
+				} else if (!strcmp("[AudioInput]", category_name)) {
 					category = CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT;
-				}
-				else if( !strcmp( "[VideoOutput]", category_name ) )
-				{
+				} else if (!strcmp("[VideoOutput]", category_name)) {
 					category = CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT;
-				}
-				else if( !strcmp( "[Capture]", category_name ) )
-				{
+				} else if (!strcmp("[Capture]", category_name)) {
 					category = CONFIGURE_CATEGORY_MAIN_CAPTURE;
-				}
-				else if( !strcmp( "[Record]", category_name ) )
-				{
+				} else if (!strcmp("[Record]", category_name)) {
 					category = CONFIGURE_CATEGORY_MAIN_RECORD;
-				}
-				else if( !strcmp( "[VideoEncoder]", category_name ) )
-				{
+				} else if (!strcmp("[VideoEncoder]", category_name)) {
 					category = CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER;
-				}
-				else if( !strcmp( "[AudioEncoder]", category_name ) )
-				{
+				} else if (!strcmp("[AudioEncoder]", category_name)) {
 					category = CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER;
-				}
-				else if( !strcmp( "[ImageEncoder]", category_name ) )
-				{
+				} else if (!strcmp("[ImageEncoder]", category_name)) {
 					category = CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER;
-				}
-				else if( !strcmp( "[Mux]", category_name ) )
-				{
+				} else if (!strcmp("[Mux]", category_name)) {
 					category = CONFIGURE_CATEGORY_MAIN_MUX;
 				}
-			}
-			else
-			{
-				if( !strcmp( "[Camera]", category_name ) )
-				{
+			} else {
+				if (!strcmp("[Camera]", category_name)) {
 					category = CONFIGURE_CATEGORY_CTRL_CAMERA;
-				}
-				else if( !strcmp( "[Strobe]", category_name ) )
-				{
+				} else if (!strcmp("[Strobe]", category_name)) {
 					category = CONFIGURE_CATEGORY_CTRL_STROBE;
-				}
-				else if( !strcmp( "[Effect]", category_name ) )
-				{
+				} else if (!strcmp("[Effect]", category_name)) {
 					category = CONFIGURE_CATEGORY_CTRL_EFFECT;
-				}
-				else if( !strcmp( "[Photograph]", category_name ) )
-				{
+				} else if (!strcmp("[Photograph]", category_name))	{
 					category = CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH;
-				}
-				else if( !strcmp( "[Capture]", category_name ) )
-				{
+				} else if (!strcmp("[Capture]", category_name)) {
 					category = CONFIGURE_CATEGORY_CTRL_CAPTURE;
-				}
-				else if( !strcmp( "[Detect]", category_name ) )
-				{
+				} else if (!strcmp("[Detect]", category_name)) {
 					category = CONFIGURE_CATEGORY_CTRL_DETECT;
 				}
 			}
 
-			if( category != -1 )
-			{
-				_mmcamcorder_conf_add_info( handle, type, &(new_conf->info[category]),
-						buffer_details, category, count_details );
-			}
-			else
-			{
-				_mmcam_dbg_warn( "No matched category[%s],type[%d]... check it.", category_name, type );
+			if (category != -1) {
+				_mmcamcorder_conf_add_info(handle, type, &(new_conf->info[category]),
+											buffer_details, category, count_details);
+			} else {
+				_mmcam_dbg_warn("No matched category[%s],type[%d]... check it.", category_name, type);
 			}
 
-			// Free memory
+			/* Free memory */
 			{
 				int i;
 
-				for( i = 0 ; i < count_details ; i++ )
-				{
-					SAFE_G_FREE( buffer_details[i] );
+				for (i = 0 ; i < count_details ; i++) {
+					SAFE_G_FREE(buffer_details[i]);
 				}
 			}
 		}
@@ -1189,11 +1134,11 @@ int _mmcamcorder_conf_parse_info(MMHandleType handle, int type, FILE* fd, camera
 		SAFE_G_FREE(category_name);
 	}
 
-	//(*configure_info) = new_conf;
+	/* (*configure_info) = new_conf; */
 
-	SAFE_G_FREE( buffer_string );
+	SAFE_G_FREE(buffer_string);
 
-	/*_mmcam_dbg_log( "Done." );*/
+	/*_mmcam_dbg_log("Done.");*/
 
 	return MM_ERROR_NONE;
 }
@@ -1221,18 +1166,16 @@ void _mmcamcorder_conf_release_info(MMHandleType handle, camera_conf **configure
 
 	mmf_return_if_fail(temp_conf);
 
-	if ((*configure_info)->type == CONFIGURE_TYPE_MAIN) {
+	if ((*configure_info)->type == CONFIGURE_TYPE_MAIN)
 		category_num = CONFIGURE_CATEGORY_MAIN_NUM;
-	} else {
+	else
 		category_num = CONFIGURE_CATEGORY_CTRL_NUM;
-	}
 
 	for (i = 0 ; i < category_num ; i++) {
 		if (temp_conf->info[i]) {
 			for (j = 0 ; j < temp_conf->info[i]->count ; j++) {
-				if (temp_conf->info[i]->detail_info[j] == NULL) {
+				if (temp_conf->info[i]->detail_info[j] == NULL)
 					continue;
-				}
 
 				if (_mmcamcorder_conf_get_value_type(handle, temp_conf->type, i, ((type_element*)(temp_conf->info[i]->detail_info[j]))->name, &type)) {
 					switch (type) {
@@ -1268,6 +1211,7 @@ void _mmcamcorder_conf_release_info(MMHandleType handle, camera_conf **configure
 							for (k = 0 ; k < count ; k++) {
 								SAFE_G_FREE(temp_string_array->value[k]);
 							}
+
 							SAFE_G_FREE(temp_string_array->value);
 						}
 						SAFE_G_FREE(temp_string_array->default_value);
@@ -1330,38 +1274,30 @@ int _mmcamcorder_conf_get_value_type(MMHandleType handle, int type, int category
 		return FALSE;
 	}
 
-	/*_mmcam_dbg_log( "Entered..." );*/
+	/*_mmcam_dbg_log("Entered...");*/
 
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(name, FALSE);
 
-	if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
-	{
-		_mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
+	if (!_mmcamcorder_conf_get_category_size(handle, type, category, &count_value)) {
+		_mmcam_dbg_warn("No matched category... check it... categoty[%d]", category);
 		return FALSE;
 	}
 
-	/*_mmcam_dbg_log( "Number of value : [%d]", count_value );*/
+	/*_mmcam_dbg_log("Number of value : [%d]", count_value);*/
 
-	if( type == CONFIGURE_TYPE_MAIN )
-	{
-		for( i = 0 ; i < count_value ; i++ )
-		{
-			if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
-			{
+	if (type == CONFIGURE_TYPE_MAIN) {
+		for (i = 0 ; i < count_value ; i++) {
+			if (!strcmp(hcamcorder->conf_main_info_table[category][i].name, name)) {
 				*value_type = hcamcorder->conf_main_info_table[category][i].value_type;
-				/*_mmcam_dbg_log( "Category[%d],Name[%s],Type[%d]", category, name, *value_type );*/
+				/*_mmcam_dbg_log("Category[%d],Name[%s],Type[%d]", category, name, *value_type);*/
 				return TRUE;
 			}
 		}
-	}
-	else
-	{
-		for( i = 0 ; i < count_value ; i++ )
-		{
-			if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
-			{
+	} else {
+		for (i = 0 ; i < count_value ; i++) {
+			if (!strcmp(hcamcorder->conf_ctrl_info_table[category][i].name, name)) {
 				*value_type = hcamcorder->conf_ctrl_info_table[category][i].value_type;
-				/*_mmcam_dbg_log( "Category[%d],Name[%s],Type[%d]", category, name, *value_type );*/
+				/*_mmcam_dbg_log("Category[%d],Name[%s],Type[%d]", category, name, *value_type);*/
 				return TRUE;
 			}
 		}
@@ -1371,7 +1307,7 @@ int _mmcamcorder_conf_get_value_type(MMHandleType handle, int type, int category
 }
 
 
-int _mmcamcorder_conf_add_info(MMHandleType handle, int type, conf_detail** info, char** buffer_details, int category, int count_details )
+int _mmcamcorder_conf_add_info(MMHandleType handle, int type, conf_detail** info, char** buffer_details, int category, int count_details)
 {
 	const int BUFFER_NUM_TOKEN = 256;
 
@@ -1387,9 +1323,9 @@ int _mmcamcorder_conf_add_info(MMHandleType handle, int type, conf_detail** info
 	const char *delimiters_sub = " |\t\n";
 	const char *delimiters_3rd = "|\n";
 
-	mmf_return_val_if_fail( buffer_details, FALSE );
+	mmf_return_val_if_fail(buffer_details, FALSE);
 
-	(*info) = (conf_detail*)g_malloc0( sizeof(conf_detail) );
+	(*info) = (conf_detail*)g_malloc0(sizeof(conf_detail));
 	if (*info == NULL) {
 		_mmcam_dbg_err("allocation failed");
 		return FALSE;
@@ -1397,56 +1333,56 @@ int _mmcamcorder_conf_add_info(MMHandleType handle, int type, conf_detail** info
 	(*info)->detail_info = (void**)g_malloc0(sizeof(void*) * count_details);
 	(*info)->count = count_details;
 
-	for ( i = 0 ; i < count_details ; i++ ) {
+	for (i = 0 ; i < count_details ; i++) {
 		/*_mmcam_dbg_log("Read line\"%s\"", buffer_details[i]);*/
 		count_token = 0;
-		token = strtok_r( buffer_details[i], delimiters, &user_ptr );
+		token = strtok_r(buffer_details[i], delimiters, &user_ptr);
 
 		if (token) {
 			buffer_token[count_token] = token;
 			count_token++;
 		} else {
 			(*info)->detail_info[i] = NULL;
-			_mmcam_dbg_warn( "No token... check it.[%s]", buffer_details[i] );
+			_mmcam_dbg_warn("No token... check it.[%s]", buffer_details[i]);
 			continue;
 		}
 
 		if (!_mmcamcorder_conf_get_value_type(handle, type, category, buffer_token[0], &value_type)) {
 			(*info)->detail_info[i] = NULL;
-			_mmcam_dbg_warn( "Failed to get value type... check it. Category[%d],Name[%s]", category, buffer_token[0] );
+			_mmcam_dbg_warn("Failed to get value type... check it. Category[%d],Name[%s]", category, buffer_token[0]);
 			continue;
 		}
 
 		if (value_type != CONFIGURE_VALUE_STRING && value_type != CONFIGURE_VALUE_STRING_ARRAY) {
-			token = strtok_r( NULL, delimiters, &user_ptr );
+			token = strtok_r(NULL, delimiters, &user_ptr);
 			while (token) {
 				buffer_token[count_token] = token;
 				/*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
 				count_token++;
-				token = strtok_r( NULL, delimiters, &user_ptr );
+				token = strtok_r(NULL, delimiters, &user_ptr);
 			}
 
 			if (count_token < 2) {
 				(*info)->detail_info[i] = NULL;
-				_mmcam_dbg_warn( "Number of token is too small... check it.[%s]", buffer_details[i] );
+				_mmcam_dbg_warn("Number of token is too small... check it.[%s]", buffer_details[i]);
 				continue;
 			}
 		} else { /* CONFIGURE_VALUE_STRING or CONFIGURE_VALUE_STRING_ARRAY */
 			/* skip "=" */
-			strtok_r( NULL, delimiters_sub, &user_ptr );
+			strtok_r(NULL, delimiters_sub, &user_ptr);
 
 			if (value_type == CONFIGURE_VALUE_STRING_ARRAY) {
-				token = strtok_r( NULL, delimiters_sub, &user_ptr );
+				token = strtok_r(NULL, delimiters_sub, &user_ptr);
 				while (token) {
 					buffer_token[count_token] = token;
 					/*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
 					count_token++;
-					token = strtok_r( NULL, delimiters_sub, &user_ptr );
+					token = strtok_r(NULL, delimiters_sub, &user_ptr);
 				}
 			} else { /* CONFIGURE_VALUE_STRING */
-				token = strtok_r( NULL, delimiters_3rd, &user_ptr );
+				token = strtok_r(NULL, delimiters_3rd, &user_ptr);
 				if (token) {
-					g_strchug( token );
+					g_strchug(token);
 					buffer_token[count_token] = token;
 					/*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
 					count_token++;
@@ -1455,253 +1391,252 @@ int _mmcamcorder_conf_add_info(MMHandleType handle, int type, conf_detail** info
 
 			if (count_token < 2) {
 				(*info)->detail_info[i] = NULL;
-				_mmcam_dbg_warn( "No string value... check it.[%s]", buffer_details[i] );
+				_mmcam_dbg_warn("No string value... check it.[%s]", buffer_details[i]);
 				continue;
 			}
 		}
 
-		switch (value_type)
+		switch (value_type) {
+		case CONFIGURE_VALUE_INT:
 		{
-			case CONFIGURE_VALUE_INT:
-			{
-				type_int2* new_int;
+			type_int2* new_int;
 
-				new_int        = (type_int2*)g_malloc0( sizeof(type_int2) );
-				if ( new_int == NULL ) {
-					_mmcam_dbg_err("allocation failed");
-					break;
-				}
-				new_int->name  = get_new_string( buffer_token[0] );
-				new_int->value = atoi( buffer_token[1] );
-				(*info)->detail_info[i] = (void*)new_int;
-				/*_mmcam_dbg_log("INT - name[%s],value[%d]", new_int->name, new_int->value);*/
+			new_int = (type_int2*)g_malloc0(sizeof(type_int2));
+			if (new_int == NULL) {
+				_mmcam_dbg_err("allocation failed");
 				break;
 			}
-			case CONFIGURE_VALUE_INT_RANGE:
-			{
-				type_int_range* new_int_range;
+			new_int->name  = get_new_string(buffer_token[0]);
+			new_int->value = atoi(buffer_token[1]);
+			(*info)->detail_info[i] = (void*)new_int;
+			/*_mmcam_dbg_log("INT - name[%s],value[%d]", new_int->name, new_int->value);*/
+			break;
+		}
+		case CONFIGURE_VALUE_INT_RANGE:
+		{
+			type_int_range* new_int_range;
 
-				new_int_range                = (type_int_range*)g_malloc0( sizeof(type_int_range) );
-				if ( new_int_range == NULL ) {
-					_mmcam_dbg_err("allocation failed");
-					break;
-				}
-				new_int_range->name          = get_new_string( buffer_token[0] );
-				new_int_range->min           = atoi( buffer_token[1] );
-				new_int_range->max           = atoi( buffer_token[2] );
-				new_int_range->default_value = atoi( buffer_token[3] );
-				(*info)->detail_info[i]      = (void*)new_int_range;
-				/*
-				_mmcam_dbg_log("INT RANGE - name[%s],min[%d],max[%d],default[%d]",
-						new_int_range->name,
-						new_int_range->min,
-						new_int_range->max,
-						new_int_range->default_value);
-				*/
+			new_int_range = (type_int_range*)g_malloc0(sizeof(type_int_range));
+			if (new_int_range == NULL) {
+				_mmcam_dbg_err("allocation failed");
 				break;
 			}
-			case CONFIGURE_VALUE_INT_ARRAY:
-			{
-				int count_value = count_token - 2;
-				type_int_array* new_int_array;
+			new_int_range->name          = get_new_string(buffer_token[0]);
+			new_int_range->min           = atoi(buffer_token[1]);
+			new_int_range->max           = atoi(buffer_token[2]);
+			new_int_range->default_value = atoi(buffer_token[3]);
+			(*info)->detail_info[i]      = (void*)new_int_range;
+			/*
+			_mmcam_dbg_log("INT RANGE - name[%s],min[%d],max[%d],default[%d]",
+				new_int_range->name,
+				new_int_range->min,
+				new_int_range->max,
+				new_int_range->default_value);
+			*/
+			break;
+		}
+		case CONFIGURE_VALUE_INT_ARRAY:
+		{
+			int count_value = count_token - 2;
+			type_int_array* new_int_array;
 
-				new_int_array = (type_int_array*)g_malloc0( sizeof(type_int_array) );
-				if (new_int_array == NULL) {
-					_mmcam_dbg_err("allocation failed");
-					break;
-				}
-				new_int_array->name = get_new_string( buffer_token[0] );
-				new_int_array->value = (int*)g_malloc0( sizeof(int)*count_value );
-				if (new_int_array->value == NULL) {
-					SAFE_G_FREE(new_int_array->name);
-					SAFE_G_FREE(new_int_array);
-					_mmcam_dbg_err("allocation failed");
-					break;
-				}
-				new_int_array->count = count_value;
+			new_int_array = (type_int_array*)g_malloc0(sizeof(type_int_array));
+			if (new_int_array == NULL) {
+				_mmcam_dbg_err("allocation failed");
+				break;
+			}
+			new_int_array->name = get_new_string(buffer_token[0]);
+			new_int_array->value = (int*)g_malloc0(sizeof(int)*count_value);
+			if (new_int_array->value == NULL) {
+				SAFE_G_FREE(new_int_array->name);
+				SAFE_G_FREE(new_int_array);
+				_mmcam_dbg_err("allocation failed");
+				break;
+			}
+			new_int_array->count = count_value;
 
-				/*_mmcam_dbg_log("INT ARRAY - name[%s]", new_int_array->name);*/
-				for ( j = 0 ; j < count_value ; j++ ) {
-					new_int_array->value[j] = atoi( buffer_token[j+1] );
-					/*_mmcam_dbg_log("   index[%d] - value[%d]", j, new_int_array->value[j]);*/
-				}
+			/*_mmcam_dbg_log("INT ARRAY - name[%s]", new_int_array->name);*/
+			for (j = 0 ; j < count_value ; j++) {
+				new_int_array->value[j] = atoi(buffer_token[j+1]);
+				/*_mmcam_dbg_log("   index[%d] - value[%d]", j, new_int_array->value[j]);*/
+			}
 
-				new_int_array->default_value = atoi( buffer_token[count_token-1] );
-				/*_mmcam_dbg_log("   default value[%d]", new_int_array->default_value);*/
+			new_int_array->default_value = atoi(buffer_token[count_token-1]);
+			/*_mmcam_dbg_log("   default value[%d]", new_int_array->default_value);*/
 
-				(*info)->detail_info[i] = (void*)new_int_array;
+			(*info)->detail_info[i] = (void*)new_int_array;
+			break;
+		}
+		case CONFIGURE_VALUE_INT_PAIR_ARRAY:
+		{
+			int count_value = (count_token - 3) >> 1;
+			type_int_pair_array* new_int_pair_array;
+
+			new_int_pair_array = (type_int_pair_array*)g_malloc0(sizeof(type_int_pair_array));
+			if (new_int_pair_array == NULL) {
+				_mmcam_dbg_err("allocation failed");
 				break;
 			}
-			case CONFIGURE_VALUE_INT_PAIR_ARRAY:
-			{
-				int count_value = ( count_token - 3 ) >> 1;
-				type_int_pair_array* new_int_pair_array;
-
-				new_int_pair_array = (type_int_pair_array*)g_malloc0( sizeof(type_int_pair_array) );
-				if ( new_int_pair_array == NULL ) {
-					_mmcam_dbg_err("allocation failed");
-					break;
-				}
-				new_int_pair_array->name     = get_new_string( buffer_token[0] );
-				new_int_pair_array->value[0] = (int*)g_malloc0( sizeof(int)*(count_value) );
-				if ( new_int_pair_array->value[0] == NULL ) {
-					SAFE_G_FREE(new_int_pair_array->name);
-					SAFE_G_FREE(new_int_pair_array);
-					_mmcam_dbg_err("allocation failed");
-					break;
-				}
-				new_int_pair_array->value[1] = (int*)g_malloc0( sizeof(int)*(count_value) );
-				if ( new_int_pair_array->value[1] == NULL ) {
-					SAFE_G_FREE(new_int_pair_array->value[0]);
-					SAFE_G_FREE(new_int_pair_array->name);
-					SAFE_G_FREE(new_int_pair_array);
-					_mmcam_dbg_err("allocation failed");
-					break;
-				}
-				new_int_pair_array->count    = count_value;
-
-				/*_mmcam_dbg_log("INT PAIR ARRAY - name[%s],count[%d]", new_int_pair_array->name, count_value);*/
-				for ( j = 0 ; j < count_value ; j++ ) {
-					new_int_pair_array->value[0][j] = atoi( buffer_token[(j<<1)+1] );
-					new_int_pair_array->value[1][j] = atoi( buffer_token[(j<<1)+2] );
-					/*
-					_mmcam_dbg_log("   index[%d] - value[%d,%d]", j,
-							new_int_pair_array->value[0][j],
-							new_int_pair_array->value[1][j]);
-					*/
-				}
+			new_int_pair_array->name = get_new_string(buffer_token[0]);
+			new_int_pair_array->value[0] = (int*)g_malloc0(sizeof(int)*(count_value));
+			if (new_int_pair_array->value[0] == NULL) {
+				SAFE_G_FREE(new_int_pair_array->name);
+				SAFE_G_FREE(new_int_pair_array);
+				_mmcam_dbg_err("allocation failed");
+				break;
+			}
+			new_int_pair_array->value[1] = (int*)g_malloc0(sizeof(int)*(count_value));
+			if (new_int_pair_array->value[1] == NULL) {
+				SAFE_G_FREE(new_int_pair_array->value[0]);
+				SAFE_G_FREE(new_int_pair_array->name);
+				SAFE_G_FREE(new_int_pair_array);
+				_mmcam_dbg_err("allocation failed");
+				break;
+			}
+			new_int_pair_array->count    = count_value;
 
-				new_int_pair_array->default_value[0] = atoi( buffer_token[count_token-2] );
-				new_int_pair_array->default_value[1] = atoi( buffer_token[count_token-1] );
+			/*_mmcam_dbg_log("INT PAIR ARRAY - name[%s],count[%d]", new_int_pair_array->name, count_value);*/
+			for (j = 0 ; j < count_value ; j++) {
+				new_int_pair_array->value[0][j] = atoi(buffer_token[(j<<1)+1]);
+				new_int_pair_array->value[1][j] = atoi(buffer_token[(j<<1)+2]);
 				/*
-				_mmcam_dbg_log("   default value[%d,%d]",
-						new_int_pair_array->default_value[0],
-						new_int_pair_array->default_value[1]);
+				_mmcam_dbg_log("   index[%d] - value[%d,%d]", j,
+					new_int_pair_array->value[0][j],
+					new_int_pair_array->value[1][j]);
 				*/
-				(*info)->detail_info[i] = (void*)new_int_pair_array;
-				break;
 			}
-			case CONFIGURE_VALUE_STRING:
-			{
-				type_string2* new_string;
 
-				new_string = (type_string2*)g_malloc0( sizeof(type_string2) );
-				if (new_string == NULL) {
-					_mmcam_dbg_err("allocation failed");
-					break;
-				}
-				new_string->name  = get_new_string( buffer_token[0] );
-				new_string->value = get_new_string( buffer_token[1] );
-				(*info)->detail_info[i]	= (void*)new_string;
+			new_int_pair_array->default_value[0] = atoi(buffer_token[count_token-2]);
+			new_int_pair_array->default_value[1] = atoi(buffer_token[count_token-1]);
+			/*
+			_mmcam_dbg_log("   default value[%d,%d]",
+				new_int_pair_array->default_value[0],
+				new_int_pair_array->default_value[1]);
+			*/
+			(*info)->detail_info[i] = (void*)new_int_pair_array;
+			break;
+		}
+		case CONFIGURE_VALUE_STRING:
+		{
+			type_string2* new_string;
 
-				/*_mmcam_dbg_log("STRING - name[%s],value[%s]", new_string->name, new_string->value);*/
+			new_string = (type_string2*)g_malloc0(sizeof(type_string2));
+			if (new_string == NULL) {
+				_mmcam_dbg_err("allocation failed");
 				break;
 			}
-			case CONFIGURE_VALUE_STRING_ARRAY:
-			{
-				int count_value = count_token - 2;
-				type_string_array* new_string_array;
+			new_string->name  = get_new_string(buffer_token[0]);
+			new_string->value = get_new_string(buffer_token[1]);
+			(*info)->detail_info[i]	= (void*)new_string;
 
-				new_string_array = (type_string_array*)g_malloc0( sizeof(type_string_array) );
-				if ( new_string_array == NULL ) {
-					break;
-				}
-				new_string_array->name  = get_new_string( buffer_token[0] );
-				new_string_array->count = count_value;
-				new_string_array->value = (char**)g_malloc0( sizeof(char*)*count_value );
-				if ( new_string_array->value == NULL ) {
-					SAFE_G_FREE(new_string_array->name);
-					SAFE_G_FREE(new_string_array);
-					_mmcam_dbg_err("allocation failed");
-					break;
-				}
-				/*_mmcam_dbg_log("STRING ARRAY - name[%s]", new_string_array->name);*/
-				for ( j = 0 ; j < count_value ; j++ ) {
-					new_string_array->value[j] = get_new_string( buffer_token[j+1] );
-					/*_mmcam_dbg_log("   index[%d] - value[%s]", j, new_string_array->value[j]);*/
-				}
+			/*_mmcam_dbg_log("STRING - name[%s],value[%s]", new_string->name, new_string->value);*/
+			break;
+		}
+		case CONFIGURE_VALUE_STRING_ARRAY:
+		{
+			int count_value = count_token - 2;
+			type_string_array* new_string_array;
 
-				new_string_array->default_value = get_new_string( buffer_token[count_token-1] );
-				/*_mmcam_dbg_log("   default value[%s]", new_string_array->default_value);*/
-				(*info)->detail_info[i]	= (void*)new_string_array;
+			new_string_array = (type_string_array*)g_malloc0(sizeof(type_string_array));
+			if (new_string_array == NULL)
+				break;
+
+			new_string_array->name  = get_new_string(buffer_token[0]);
+			new_string_array->count = count_value;
+			new_string_array->value = (char**)g_malloc0(sizeof(char*)*count_value);
+			if (new_string_array->value == NULL) {
+				SAFE_G_FREE(new_string_array->name);
+				SAFE_G_FREE(new_string_array);
+				_mmcam_dbg_err("allocation failed");
 				break;
 			}
-			case CONFIGURE_VALUE_ELEMENT:
-			{
-				type_element2* new_element;
+			/*_mmcam_dbg_log("STRING ARRAY - name[%s]", new_string_array->name);*/
+			for (j = 0 ; j < count_value ; j++) {
+				new_string_array->value[j] = get_new_string(buffer_token[j+1]);
+				/*_mmcam_dbg_log("   index[%d] - value[%s]", j, new_string_array->value[j]);*/
+			}
 
-				new_element = (type_element2*)g_malloc0( sizeof(type_element2) );
-				if ( new_element == NULL ) {
-					_mmcam_dbg_err("allocation failed");
-					break;
-				}
-				new_element->name         = get_new_string( buffer_token[0] );
-				new_element->element_name = get_new_string( buffer_token[1] );
-				new_element->count_int    = atoi( buffer_token[2] );
-				new_element->value_int    = NULL;
-				new_element->count_string = atoi( buffer_token[3] );
-				new_element->value_string = NULL;
-				/*
-				_mmcam_dbg_log("Element - name[%s],element_name[%s],count_int[%d],count_string[%d]",
-				               new_element->name, new_element->element_name, new_element->count_int, new_element->count_string);
-				*/
+			new_string_array->default_value = get_new_string(buffer_token[count_token-1]);
+			/*_mmcam_dbg_log("   default value[%s]", new_string_array->default_value);*/
+			(*info)->detail_info[i]	= (void*)new_string_array;
+			break;
+		}
+		case CONFIGURE_VALUE_ELEMENT:
+		{
+			type_element2* new_element;
 
-				/* add int values */
-				if ( new_element->count_int > 0 && new_element->count_int <= 30 ) {
-					new_element->value_int = (type_int2**)g_malloc0( sizeof(type_int2*)*(new_element->count_int) );
-					if ( new_element->value_int) {
-						for ( j = 0 ; j < new_element->count_int ; j++ ) {
-							new_element->value_int[j]        = (type_int2*)g_malloc0( sizeof(type_int2) );
-							if ( new_element->value_int[j] ) {
-								new_element->value_int[j]->name  = get_new_string( buffer_token[4+(j<<1)] );
-								new_element->value_int[j]->value = atoi( buffer_token[5+(j<<1)] );
-							} else {
-								_mmcam_dbg_err("allocation failed");
-							}
-							/*
-							_mmcam_dbg_log("   Element INT[%d] - name[%s],value[%d]",
-							               j, new_element->value_int[j]->name, new_element->value_int[j]->value);
-							*/
+			new_element = (type_element2*)g_malloc0(sizeof(type_element2));
+			if (new_element == NULL) {
+				_mmcam_dbg_err("allocation failed");
+				break;
+			}
+			new_element->name         = get_new_string(buffer_token[0]);
+			new_element->element_name = get_new_string(buffer_token[1]);
+			new_element->count_int    = atoi(buffer_token[2]);
+			new_element->value_int    = NULL;
+			new_element->count_string = atoi(buffer_token[3]);
+			new_element->value_string = NULL;
+			/*
+			_mmcam_dbg_log("Element - name[%s],element_name[%s],count_int[%d],count_string[%d]",
+				new_element->name, new_element->element_name, new_element->count_int, new_element->count_string);
+			*/
+
+			/* add int values */
+			if (new_element->count_int > 0 && new_element->count_int <= 30) {
+				new_element->value_int = (type_int2**)g_malloc0(sizeof(type_int2*)*(new_element->count_int));
+				if (new_element->value_int) {
+					for (j = 0 ; j < new_element->count_int ; j++) {
+						new_element->value_int[j] = (type_int2*)g_malloc0(sizeof(type_int2));
+						if (new_element->value_int[j]) {
+							new_element->value_int[j]->name  = get_new_string(buffer_token[4+(j<<1)]);
+							new_element->value_int[j]->value = atoi(buffer_token[5+(j<<1)]);
+						} else {
+							_mmcam_dbg_err("allocation failed");
 						}
-					} else {
-						_mmcam_dbg_err("allocation failed");
+						/*
+						_mmcam_dbg_log("   Element INT[%d] - name[%s],value[%d]",
+							j, new_element->value_int[j]->name, new_element->value_int[j]->value);
+						*/
 					}
 				} else {
-					/*_mmcam_dbg_err("invalid count - %d", new_element->count_int);*/
-					new_element->value_int = NULL;
+					_mmcam_dbg_err("allocation failed");
 				}
+			} else {
+				/*_mmcam_dbg_err("invalid count - %d", new_element->count_int);*/
+				new_element->value_int = NULL;
+			}
 
-				/* add string values */
-				if ( new_element->count_string > 0 && new_element->count_string <= 30 &&
-				     new_element->count_int >= 0 && new_element->count_int <= 30 ) {
-					new_element->value_string = (type_string2**)g_malloc0( sizeof(type_string2*)*(new_element->count_string) );
-					if (new_element->value_string) {
-						for ( ; j < new_element->count_string + new_element->count_int ; j++ ) {
-							new_element->value_string[j-new_element->count_int]	= (type_string2*)g_malloc0( sizeof(type_string2) );
-							if(new_element->value_string[j-new_element->count_int]) {
-								new_element->value_string[j-new_element->count_int]->name	= get_new_string( buffer_token[4+(j<<1)] );
-								new_element->value_string[j-new_element->count_int]->value	= get_new_string( buffer_token[5+(j<<1)] );
-								/*
-								_mmcam_dbg_log("   Element STRING[%d] - name[%s],value[%s]",
-								               j-new_element->count_int, new_element->value_string[j-new_element->count_int]->name, new_element->value_string[j-new_element->count_int]->value);
-								*/
-							} else {
-								_mmcam_dbg_err("allocation failed");
-							}
+			/* add string values */
+			if (new_element->count_string > 0 && new_element->count_string <= 30 &&
+				new_element->count_int >= 0 && new_element->count_int <= 30) {
+				new_element->value_string = (type_string2**)g_malloc0(sizeof(type_string2*)*(new_element->count_string));
+				if (new_element->value_string) {
+					for ( ; j < new_element->count_string + new_element->count_int ; j++) {
+						new_element->value_string[j-new_element->count_int]	= (type_string2*)g_malloc0(sizeof(type_string2));
+						if (new_element->value_string[j-new_element->count_int]) {
+							new_element->value_string[j-new_element->count_int]->name	= get_new_string(buffer_token[4+(j<<1)]);
+							new_element->value_string[j-new_element->count_int]->value	= get_new_string(buffer_token[5+(j<<1)]);
+							/*
+							_mmcam_dbg_log("   Element STRING[%d] - name[%s],value[%s]",
+								j-new_element->count_int, new_element->value_string[j-new_element->count_int]->name, new_element->value_string[j-new_element->count_int]->value);
+							*/
+						} else {
+							_mmcam_dbg_err("allocation failed");
 						}
-					} else {
-						_mmcam_dbg_err("malloc failed : %d", sizeof(type_string2*)*(new_element->count_string));
 					}
 				} else {
-					/*_mmcam_dbg_err("invalid count - %d", new_element->count_string);*/
-					new_element->value_string = NULL;
+					_mmcam_dbg_err("malloc failed : %d", sizeof(type_string2*)*(new_element->count_string));
 				}
-
-				(*info)->detail_info[i] = (void*)new_element;
-				break;
+			} else {
+				/*_mmcam_dbg_err("invalid count - %d", new_element->count_string);*/
+				new_element->value_string = NULL;
 			}
-			default:
-				break;
+
+			(*info)->detail_info[i] = (void*)new_element;
+			break;
+		}
+		default:
+			break;
 		}
 	}
 
@@ -1714,72 +1649,61 @@ int _mmcamcorder_conf_get_value_int(MMHandleType handle, camera_conf* configure_
 	int i, count;
 	conf_detail* info;
 
-	//_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+	/* _mmcam_dbg_log("Entered... category[%d],name[%s]", category, name); */
 
-	mmf_return_val_if_fail( configure_info, FALSE );
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(configure_info, FALSE);
+	mmf_return_val_if_fail(name, FALSE);
 
-	if( configure_info->info[category] )
-	{
+	if (configure_info->info[category]) {
 		count = configure_info->info[category]->count;
 		info = configure_info->info[category];
 
-		for( i = 0 ; i < count ; i++ )
-		{
-			if( info->detail_info[i] == NULL )
-			{
+		for (i = 0 ; i < count ; i++) {
+			if (info->detail_info[i] == NULL)
 				continue;
-			}
 
-			if( !strcmp( ((type_int*)(info->detail_info[i]))->name , name ) )
-			{
+			if (!strcmp(((type_int*)(info->detail_info[i]))->name , name)) {
 				*value = ((type_int*)(info->detail_info[i]))->value;
-				//_mmcam_dbg_log( "Get[%s] int[%d]", name, *value );
+				/* _mmcam_dbg_log("Get[%s] int[%d]", name, *value); */
 				return TRUE;
 			}
 		}
 	}
 
-	if( _mmcamcorder_conf_get_default_value_int( handle, configure_info->type, category, name, value ) )
-	{
-		//_mmcam_dbg_log( "Get[%s] int[%d]", name, *value );
+	if (_mmcamcorder_conf_get_default_value_int(handle, configure_info->type, category, name, value)) {
+		/* _mmcam_dbg_log("Get[%s] int[%d]", name, *value); */
 		return TRUE;
 	}
 
-	_mmcam_dbg_warn( "Faild to get int... check it...Category[%d],Name[%s]", category, name );
+	_mmcam_dbg_warn("Faild to get int... check it...Category[%d],Name[%s]", category, name);
 
 	return FALSE;
 }
 
 int
-_mmcamcorder_conf_get_value_int_range( camera_conf* configure_info, int category, const char* name, type_int_range** value )
+_mmcamcorder_conf_get_value_int_range(camera_conf* configure_info, int category, const char* name, type_int_range** value)
 {
 	int i, count;
 	conf_detail* info;
 
-	//_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+	/* _mmcam_dbg_log("Entered... category[%d],name[%s]", category, name); */
 
-	mmf_return_val_if_fail( configure_info, FALSE );
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(configure_info, FALSE);
+	mmf_return_val_if_fail(name, FALSE);
 
-	if( configure_info->info[category] )
-	{
+	if (configure_info->info[category]) {
 		count = configure_info->info[category]->count;
 		info = configure_info->info[category];
 
-		for( i = 0 ; i < count ; i++ )
-		{
-			if( info->detail_info[i] == NULL )
-			{
+		for (i = 0 ; i < count ; i++) {
+			if (info->detail_info[i] == NULL)
 				continue;
-			}
 
-			if( !strcmp( ((type_int_range*)(info->detail_info[i]))->name , name ) )
-			{
+			if (!strcmp(((type_int_range*)(info->detail_info[i]))->name , name)) {
 				*value = (type_int_range*)(info->detail_info[i]);
 				/*
-				_mmcam_dbg_log( "Get[%s] int range - min[%d],max[%d],default[%d]",
-						name, (*value)->min, (*value)->max, (*value)->default_value );
+				_mmcam_dbg_log("Get[%s] int range - min[%d],max[%d],default[%d]",
+					name, (*value)->min, (*value)->max, (*value)->default_value);
 				*/
 				return TRUE;
 			}
@@ -1794,34 +1718,29 @@ _mmcamcorder_conf_get_value_int_range( camera_conf* configure_info, int category
 }
 
 int
-_mmcamcorder_conf_get_value_int_array( camera_conf* configure_info, int category, const char* name, type_int_array** value )
+_mmcamcorder_conf_get_value_int_array(camera_conf* configure_info, int category, const char* name, type_int_array** value)
 {
 	int i, count;
 	conf_detail* info;
 
-	/*_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );*/
+	/*_mmcam_dbg_log("Entered... category[%d],name[%s]", category, name);*/
 
-	mmf_return_val_if_fail( configure_info, FALSE );
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(configure_info, FALSE);
+	mmf_return_val_if_fail(name, FALSE);
 
-	if( configure_info->info[category] )
-	{
+	if (configure_info->info[category]) {
 		count	= configure_info->info[category]->count;
 		info	= configure_info->info[category];
 
-		for( i = 0 ; i < count ; i++ )
-		{
-			if( info->detail_info[i] == NULL )
-			{
+		for (i = 0 ; i < count ; i++) {
+			if (info->detail_info[i] == NULL)
 				continue;
-			}
 
-			if( !strcmp( ((type_int_array*)(info->detail_info[i]))->name , name ) )
-			{
+			if (!strcmp(((type_int_array*)(info->detail_info[i]))->name , name)) {
 				*value = (type_int_array*)(info->detail_info[i]);
 				/*
-				_mmcam_dbg_log( "Get[%s] int array - [%x],count[%d],default[%d]",
-						name, (*value)->value, (*value)->count, (*value)->default_value );
+				_mmcam_dbg_log("Get[%s] int array - [%x],count[%d],default[%d]",
+					name, (*value)->value, (*value)->count, (*value)->default_value);
 				*/
 				return TRUE;
 			}
@@ -1836,35 +1755,30 @@ _mmcamcorder_conf_get_value_int_array( camera_conf* configure_info, int category
 }
 
 int
-_mmcamcorder_conf_get_value_int_pair_array( camera_conf* configure_info, int category, const char* name, type_int_pair_array** value )
+_mmcamcorder_conf_get_value_int_pair_array(camera_conf* configure_info, int category, const char* name, type_int_pair_array** value)
 {
 	int i, count;
 	conf_detail* info;
 
-	//_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+	/* _mmcam_dbg_log("Entered... category[%d],name[%s]", category, name); */
 
-	mmf_return_val_if_fail( configure_info, FALSE );
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(configure_info, FALSE);
+	mmf_return_val_if_fail(name, FALSE);
 
-	if( configure_info->info[category] )
-	{
+	if (configure_info->info[category]) {
 		count = configure_info->info[category]->count;
 		info = configure_info->info[category];
 
-		for( i = 0 ; i < count ; i++ )
-		{
-			if( info->detail_info[i] == NULL )
-			{
+		for (i = 0 ; i < count ; i++) {
+			if (info->detail_info[i] == NULL)
 				continue;
-			}
 
-			if( !strcmp( ((type_int_pair_array*)(info->detail_info[i]))->name , name ) )
-			{
+			if (!strcmp(((type_int_pair_array*)(info->detail_info[i]))->name , name)) {
 				*value = (type_int_pair_array*)(info->detail_info[i]);
 				/*
-				_mmcam_dbg_log( "Get[%s] int pair array - [%x][%x],count[%d],default[%d][%d]",
-						name, (*value)->value[0], (*value)->value[1], (*value)->count,
-						(*value)->default_value[0], (*value)->default_value[1] );
+				_mmcam_dbg_log("Get[%s] int pair array - [%x][%x],count[%d],default[%d][%d]",
+					name, (*value)->value[0], (*value)->value[1], (*value)->count,
+					(*value)->default_value[0], (*value)->default_value[1]);
 				*/
 				return TRUE;
 			}
@@ -1873,7 +1787,7 @@ _mmcamcorder_conf_get_value_int_pair_array( camera_conf* configure_info, int cat
 
 	*value = NULL;
 
-	_mmcam_dbg_warn( "Faild to get int pair array... check it...Category[%d],Name[%s]", category, name );
+	_mmcam_dbg_warn("Faild to get int pair array... check it...Category[%d],Name[%s]", category, name);
 
 	return FALSE;
 }
@@ -1883,72 +1797,61 @@ int _mmcamcorder_conf_get_value_string(MMHandleType handle, camera_conf* configu
 	int i, count;
 	conf_detail* info;
 
-	//_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+	/* _mmcam_dbg_log("Entered... category[%d],name[%s]", category, name); */
 
-	mmf_return_val_if_fail( configure_info, FALSE );
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(configure_info, FALSE);
+	mmf_return_val_if_fail(name, FALSE);
 
-	if( configure_info->info[category] )
-	{
+	if (configure_info->info[category]) {
 		count = configure_info->info[category]->count;
 		info = configure_info->info[category];
 
-		for( i = 0 ; i < count ; i++ )
-		{
-			if( info->detail_info[i] == NULL )
-			{
+		for (i = 0 ; i < count ; i++) {
+			if (info->detail_info[i] == NULL)
 				continue;
-			}
 
-			if( !strcmp( ((type_string*)(info->detail_info[i]))->name , name ) )
-			{
+			if (!strcmp(((type_string*)(info->detail_info[i]))->name , name)) {
 				*value = ((type_string*)(info->detail_info[i]))->value;
-				//_mmcam_dbg_log( "Get[%s] string[%s]", name, *value );
+				/* _mmcam_dbg_log( "Get[%s] string[%s]", name, *value ); */
 				return TRUE;
 			}
 		}
 	}
 
-	if( _mmcamcorder_conf_get_default_value_string(handle, configure_info->type, category, name, value ) )
-	{
-		//_mmcam_dbg_log( "Get[%s]string[%s]", name, *value );
+	if (_mmcamcorder_conf_get_default_value_string(handle, configure_info->type, category, name, value)) {
+		/* _mmcam_dbg_log("Get[%s]string[%s]", name, *value); */
 		return TRUE;
 	}
 
-	_mmcam_dbg_warn( "Faild to get string... check it...Category[%d],Name[%s]", category, name );
+	_mmcam_dbg_warn("Faild to get string... check it...Category[%d],Name[%s]", category, name);
 
 	return FALSE;
 }
 
 int
-_mmcamcorder_conf_get_value_string_array( camera_conf* configure_info, int category, const char* name, type_string_array** value )
+_mmcamcorder_conf_get_value_string_array(camera_conf* configure_info, int category, const char* name, type_string_array** value)
 {
 	int i, count;
 	conf_detail* info;
 
-	//_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+	/* _mmcam_dbg_log("Entered... category[%d],name[%s]", category, name); */
 
-	mmf_return_val_if_fail( configure_info, FALSE );
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(configure_info, FALSE);
+	mmf_return_val_if_fail(name, FALSE);
 
-	if( configure_info->info[category] )
-	{
+	if (configure_info->info[category]) {
 		count = configure_info->info[category]->count;
 		info = configure_info->info[category];
 
-		for( i = 0 ; i < count ; i++ )
-		{
-			if( info->detail_info[i] == NULL )
-			{
+		for (i = 0 ; i < count ; i++) {
+			if (info->detail_info[i] == NULL)
 				continue;
-			}
 
-			if( !strcmp( ((type_string_array*)(info->detail_info[i]))->name , name ) )
-			{
+			if (!strcmp(((type_string_array*)(info->detail_info[i]))->name , name)) {
 				*value = (type_string_array*)(info->detail_info[i]);
 				/*
-				_mmcam_dbg_log( "Get[%s] string array - [%x],count[%d],default[%s]",
-						name, (*value)->value, (*value)->count, (*value)->default_value );
+				_mmcam_dbg_log("Get[%s] string array - [%x],count[%d],default[%s]",
+					name, (*value)->value, (*value)->count, (*value)->default_value);
 				*/
 				return TRUE;
 			}
@@ -1957,7 +1860,7 @@ _mmcamcorder_conf_get_value_string_array( camera_conf* configure_info, int categ
 
 	*value = NULL;
 
-	/*_mmcam_dbg_warn( "Faild to get string array... check it...Category[%d],Name[%s]", category, name );*/
+	/*_mmcam_dbg_warn("Faild to get string array... check it...Category[%d],Name[%s]", category, name);*/
 
 	return FALSE;
 }
@@ -1967,174 +1870,154 @@ int _mmcamcorder_conf_get_element(MMHandleType handle, camera_conf* configure_in
 	int i, count;
 	conf_detail* info;
 
-	//_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+	/* _mmcam_dbg_log("Entered... category[%d], ame[%s]", category, name); */
 
-	mmf_return_val_if_fail( configure_info, FALSE );
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(configure_info, FALSE);
+	mmf_return_val_if_fail(name, FALSE);
 
-	if( configure_info->info[category] )
-	{
+	if (configure_info->info[category]) {
 		count = configure_info->info[category]->count;
 		info = configure_info->info[category];
 
-		for( i = 0 ; i < count ; i++ )
-		{
-			if( info->detail_info[i] == NULL )
-			{
+		for (i = 0 ; i < count ; i++) {
+			if (info->detail_info[i] == NULL)
 				continue;
-			}
 
-			if( !strcmp( ((type_element*)(info->detail_info[i]))->name , name ) )
-			{
+			if (!strcmp(((type_element*)(info->detail_info[i]))->name , name)) {
 				*element = (type_element*)(info->detail_info[i]);
-				//_mmcam_dbg_log( "Get[%s] element[%x]", name, *element );
+				/* _mmcam_dbg_log("Get[%s] element[%x]", name, *element); */
 				return TRUE;
 			}
 		}
 	}
 
-	if( _mmcamcorder_conf_get_default_element(handle, configure_info->type, category, name, element ) )
-	{
-		//_mmcam_dbg_log( "Get[%s] element[%x]", name, *element );
+	if (_mmcamcorder_conf_get_default_element(handle, configure_info->type, category, name, element)) {
+		/* _mmcam_dbg_log("Get[%s] element[%x]", name, *element); */
 		return TRUE;
 	}
 
-	_mmcam_dbg_warn( "Faild to get element name... check it...Category[%d],Name[%s]", category, name );
+	_mmcam_dbg_warn("Faild to get element name... check it...Category[%d],Name[%s]", category, name);
 
 	return FALSE;
 }
 
 int
-_mmcamcorder_conf_get_value_element_name( type_element* element, const char** value )
+_mmcamcorder_conf_get_value_element_name(type_element* element, const char** value)
 {
-	//_mmcam_dbg_log( "Entered..." );
+	/* _mmcam_dbg_log("Entered..."); */
 
-	mmf_return_val_if_fail( element, FALSE );
+	mmf_return_val_if_fail(element, FALSE);
 
 	*value = element->element_name;
 
-	//_mmcam_dbg_log( "Get element name : [%s]", *value );
+	/* _mmcam_dbg_log("Get element name : [%s]", *value); */
 
 	return TRUE;
 }
 
 int
-_mmcamcorder_conf_get_value_element_int( type_element* element, const char* name, int* value )
+_mmcamcorder_conf_get_value_element_int(type_element* element, const char* name, int* value)
 {
 	int i;
 
-	//_mmcam_dbg_log( "Entered..." );
+	/* _mmcam_dbg_log( "Entered..." ); */
 
-	mmf_return_val_if_fail( element, FALSE );
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(element, FALSE);
+	mmf_return_val_if_fail(name, FALSE);
 
-	for( i = 0 ; i < element->count_int ; i++ )
-	{
-		if( !strcmp( element->value_int[i]->name , name ) )
-		{
+	for (i = 0 ; i < element->count_int ; i++) {
+		if (!strcmp(element->value_int[i]->name, name)) {
 			*value = element->value_int[i]->value;
-			//_mmcam_dbg_log( "Get[%s] element int[%d]", name, *value );
+			/* _mmcam_dbg_log("Get[%s] element int[%d]", name, *value); */
 			return TRUE;
 		}
 	}
 
-	_mmcam_dbg_warn( "Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
-		element->name, name, element->count_int );
+	_mmcam_dbg_warn("Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
+		element->name, name, element->count_int);
 
 	return FALSE;
 }
 
 int
-_mmcamcorder_conf_get_value_element_string( type_element* element, const char* name, const char** value )
+_mmcamcorder_conf_get_value_element_string(type_element* element, const char* name, const char** value)
 {
 	int i;
 
-	//_mmcam_dbg_log( "Entered..." );
+	/* _mmcam_dbg_log("Entered..."); */
 
-	mmf_return_val_if_fail( element, FALSE );
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(element, FALSE);
+	mmf_return_val_if_fail(name, FALSE);
 
-	for( i = 0 ; i < element->count_string ; i++ )
-	{
-		if( !strcmp( element->value_string[i]->name , name ) )
-		{
+	for (i = 0 ; i < element->count_string ; i++) {
+		if (!strcmp(element->value_string[i]->name, name)) {
 			*value = element->value_string[i]->value;
-			//_mmcam_dbg_log( "Get[%s] element string[%s]", name, *value );
+			/*_mmcam_dbg_log("Get[%s] element string[%s]", name, *value);*/
 			return TRUE;
 		}
 	}
 
-	_mmcam_dbg_warn( "Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
-		element->name, name, element->count_string );
+	_mmcam_dbg_warn("Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
+		element->name, name, element->count_string);
 
 	return FALSE;
 }
 
 int
-_mmcamcorder_conf_set_value_element_property( GstElement* gst, type_element* element )
+_mmcamcorder_conf_set_value_element_property(GstElement* gst, type_element* element)
 {
 	int i;
 
-	//_mmcam_dbg_log( "Entered..." );
+	/* _mmcam_dbg_log("Entered..."); */
 
-	mmf_return_val_if_fail( gst, FALSE );
-	mmf_return_val_if_fail( element, FALSE );
+	mmf_return_val_if_fail(gst, FALSE);
+	mmf_return_val_if_fail(element, FALSE);
 
-	if( element->count_int == 0 )
-	{
+	if (element->count_int == 0) {
 		/*_mmcam_dbg_log( "There is no integer property to set in INI file[%s].", element->name );*/
-	}
-	else
-	{
-		if( element->value_int == NULL )
-		{
-			_mmcam_dbg_warn( "count_int[%d] is NOT zero, but value_int is NULL", element->count_int );
+	} else {
+		if (element->value_int == NULL) {
+			_mmcam_dbg_warn("count_int[%d] is NOT zero, but value_int is NULL", element->count_int);
 			return FALSE;
 		}
 
-		for( i = 0 ; i < element->count_int ; i++ )
-		{
-			MMCAMCORDER_G_OBJECT_SET( gst, element->value_int[i]->name, element->value_int[i]->value );
+		for (i = 0 ; i < element->count_int ; i++) {
+			MMCAMCORDER_G_OBJECT_SET(gst, element->value_int[i]->name, element->value_int[i]->value);
 
 			/*
-			_mmcam_dbg_log( "Element[%s] Set[%s] -> integer[%d]",
+			_mmcam_dbg_log("Element[%s] Set[%s] -> integer[%d]",
 				element->element_name,
 				element->value_int[i]->name,
-				element->value_int[i]->value );
-				*/
+				element->value_int[i]->value);
+			*/
 		}
 	}
 
-	if( element->count_string == 0 )
-	{
-		_mmcam_dbg_log( "There is no string property to set in INI file[%s].", element->name );
-	}
-	else
-	{
-		if( element->value_string == NULL )
-		{
-			_mmcam_dbg_warn( "count_string[%d] is NOT zero, but value_string is NULL", element->count_string );
+	if (element->count_string == 0) {
+		_mmcam_dbg_log("There is no string property to set in INI file[%s].", element->name);
+	} else {
+		if (element->value_string == NULL) {
+			_mmcam_dbg_warn("count_string[%d] is NOT zero, but value_string is NULL", element->count_string);
 			return FALSE;
 		}
 
-		for( i = 0 ; i < element->count_string ; i++ )
-		{
-			MMCAMCORDER_G_OBJECT_SET_POINTER( gst, element->value_string[i]->name, element->value_string[i]->value );
+		for (i = 0 ; i < element->count_string ; i++) {
+			MMCAMCORDER_G_OBJECT_SET_POINTER(gst, element->value_string[i]->name, element->value_string[i]->value);
 
-			_mmcam_dbg_log( "Element[%s] Set[%s] -> string[%s]",
+			_mmcam_dbg_log("Element[%s] Set[%s] -> string[%s]",
 				element->element_name,
 				element->value_string[i]->name,
-				element->value_string[i]->value );
+				element->value_string[i]->value);
 		}
 	}
 
-	//_mmcam_dbg_log( "Done." );
+	/* _mmcam_dbg_log( "Done." ); */
 
 	return TRUE;
 }
 
 int
-_mmcamcorder_conf_get_default_value_int(MMHandleType handle, int type, int category, const char* name, int* value )
+_mmcamcorder_conf_get_default_value_int(MMHandleType handle, int type, int category, const char* name, int* value)
 {
 	int i = 0;
 	int count_value = 0;
@@ -2146,40 +2029,32 @@ _mmcamcorder_conf_get_default_value_int(MMHandleType handle, int type, int categ
 		return FALSE;
 	}
 
-	//_mmcam_dbg_log( "Entered..." );
+	/* _mmcam_dbg_log("Entered..."); */
 
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(name, FALSE);
 
-	if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
-	{
-		_mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
+	if (!_mmcamcorder_conf_get_category_size(handle, type, category, &count_value)) {
+		_mmcam_dbg_warn("No matched category... check it... categoty[%d]", category);
 		return FALSE;
 	}
 
-	if( type == CONFIGURE_TYPE_MAIN )
-	{
-		for( i = 0 ; i < count_value ; i++ )
-		{
-			if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
-			{
+	if (type == CONFIGURE_TYPE_MAIN) {
+		for (i = 0 ; i < count_value ; i++) {
+			if (!strcmp(hcamcorder->conf_main_info_table[category][i].name, name)) {
 				*value = hcamcorder->conf_main_info_table[category][i].value_int;
 				return TRUE;
 			}
 		}
-	}
-	else
-	{
-		for( i = 0 ; i < count_value ; i++ )
-		{
-			if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
-			{
+	} else {
+		for (i = 0 ; i < count_value ; i++) {
+			if (!strcmp(hcamcorder->conf_ctrl_info_table[category][i].name, name)) {
 				*value = hcamcorder->conf_ctrl_info_table[category][i].value_int;
 				return TRUE;
 			}
 		}
 	}
 
-	_mmcam_dbg_warn( "Failed to get default int... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
+	_mmcam_dbg_warn("Failed to get default int... check it... Type[%d],Category[%d],Name[%s]", type, category, name);
 
 	return FALSE;
 }
@@ -2196,42 +2071,34 @@ int _mmcamcorder_conf_get_default_value_string(MMHandleType handle, int type, in
 		return FALSE;
 	}
 
-	//_mmcam_dbg_log( "Entered..." );
+	/* _mmcam_dbg_log("Entered..."); */
 
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(name, FALSE);
 
-	if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
-	{
-		_mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
+	if (!_mmcamcorder_conf_get_category_size(handle, type, category, &count_value)) {
+		_mmcam_dbg_warn("No matched category... check it... categoty[%d]", category);
 		return FALSE;
 	}
 
-	if( type == CONFIGURE_TYPE_MAIN )
-	{
-		for( i = 0 ; i < count_value ; i++ )
-		{
-			if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
-			{
+	if (type == CONFIGURE_TYPE_MAIN) {
+		for (i = 0 ; i < count_value ; i++) {
+			if (!strcmp(hcamcorder->conf_main_info_table[category][i].name, name)) {
 				*value = hcamcorder->conf_main_info_table[category][i].value_string;
-				_mmcam_dbg_log( "Get[%s] default string[%s]", name, *value );
+				_mmcam_dbg_log("Get[%s] default string[%s]", name, *value);
 				return TRUE;
 			}
 		}
-	}
-	else
-	{
-		for( i = 0 ; i < count_value ; i++ )
-		{
-			if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
-			{
+	} else {
+		for (i = 0 ; i < count_value ; i++) {
+			if (!strcmp(hcamcorder->conf_ctrl_info_table[category][i].name, name)) {
 				*value = hcamcorder->conf_ctrl_info_table[category][i].value_string;
-				_mmcam_dbg_log( "Get[%s] default string[%s]", name, *value );
+				_mmcam_dbg_log("Get[%s] default string[%s]", name, *value);
 				return TRUE;
 			}
 		}
 	}
 
-	_mmcam_dbg_warn( "Failed to get default string... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
+	_mmcam_dbg_warn("Failed to get default string... check it... Type[%d],Category[%d],Name[%s]", type, category, name);
 
 	return FALSE;
 }
@@ -2248,42 +2115,34 @@ int _mmcamcorder_conf_get_default_element(MMHandleType handle, int type, int cat
 		return FALSE;
 	}
 
-	//_mmcam_dbg_log( "Entered..." );
+	/* _mmcam_dbg_log("Entered..."); */
 
-	mmf_return_val_if_fail( name, FALSE );
+	mmf_return_val_if_fail(name, FALSE);
 
-	if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
-	{
-		_mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
+	if (!_mmcamcorder_conf_get_category_size(handle, type, category, &count_value)) {
+		_mmcam_dbg_warn("No matched category... check it... categoty[%d]", category);
 		return FALSE;
 	}
 
-	if( type == CONFIGURE_TYPE_MAIN )
-	{
-		for( i = 0 ; i < count_value ; i++ )
-		{
-			if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
-			{
+	if (type == CONFIGURE_TYPE_MAIN) {
+		for (i = 0 ; i < count_value ; i++) {
+			if (!strcmp(hcamcorder->conf_main_info_table[category][i].name, name)) {
 				*element = hcamcorder->conf_main_info_table[category][i].value_element;
-				_mmcam_dbg_log( "Get[%s] element[%p]", name, *element );
+				_mmcam_dbg_log("Get[%s] element[%p]", name, *element);
 				return TRUE;
 			}
 		}
-	}
-	else
-	{
-		for( i = 0 ; i < count_value ; i++ )
-		{
-			if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
-			{
+	} else {
+		for (i = 0 ; i < count_value ; i++) {
+			if (!strcmp(hcamcorder->conf_ctrl_info_table[category][i].name, name)) {
 				*element = hcamcorder->conf_ctrl_info_table[category][i].value_element;
-				_mmcam_dbg_log( "Get[%s] element[%p]", name, *element );
+				_mmcam_dbg_log("Get[%s] element[%p]", name, *element);
 				return TRUE;
 			}
 		}
 	}
 
-	_mmcam_dbg_warn( "Failed to get default element... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
+	_mmcam_dbg_warn("Failed to get default element... check it... Type[%d],Category[%d],Name[%s]", type, category, name);
 
 	return FALSE;
 }
@@ -2297,18 +2156,17 @@ int _mmcamcorder_conf_get_category_size(MMHandleType handle, int type, int categ
 		return FALSE;
 	}
 
-//	mmf_return_val_if_fail( conf_main_category_size, FALSE );
-//	mmf_return_val_if_fail( conf_ctrl_category_size, FALSE );
+	/*
+	mmf_return_val_if_fail(conf_main_category_size, FALSE);
+	mmf_return_val_if_fail(conf_ctrl_category_size, FALSE);
+	*/
 
-	if( type == CONFIGURE_TYPE_MAIN )
-	{
-		mmf_return_val_if_fail( category < CONFIGURE_CATEGORY_MAIN_NUM, FALSE );
+	if (type == CONFIGURE_TYPE_MAIN) {
+		mmf_return_val_if_fail(category < CONFIGURE_CATEGORY_MAIN_NUM, FALSE);
 
 		*size = (int)hcamcorder->conf_main_category_size[category];
-	}
-	else
-	{
-		mmf_return_val_if_fail( category < CONFIGURE_CATEGORY_CTRL_NUM, FALSE );
+	} else {
+		mmf_return_val_if_fail(category < CONFIGURE_CATEGORY_CTRL_NUM, FALSE);
 
 		*size = (int)hcamcorder->conf_ctrl_category_size[category];
 	}
@@ -2317,7 +2175,7 @@ int _mmcamcorder_conf_get_category_size(MMHandleType handle, int type, int categ
 }
 
 void
-_mmcamcorder_conf_print_info(MMHandleType handle, camera_conf** configure_info )
+_mmcamcorder_conf_print_info(MMHandleType handle, camera_conf** configure_info)
 {
 	int i, j, k, type, category_type;
 
@@ -2328,89 +2186,80 @@ _mmcamcorder_conf_print_info(MMHandleType handle, camera_conf** configure_info )
 	type_string             *temp_string;
 	type_element            *temp_element;
 
-	g_print( "[ConfigureInfoPrint] : Entered.\n" );
+	g_print("[ConfigureInfoPrint] : Entered.\n");
 
-	mmf_return_if_fail( *configure_info );
+	mmf_return_if_fail(*configure_info);
 
-	if( (*configure_info)->type == CONFIGURE_TYPE_MAIN )
-	{
+	if ((*configure_info)->type == CONFIGURE_TYPE_MAIN)
 		category_type = CONFIGURE_CATEGORY_MAIN_NUM;
-	}
 	else
-	{
 		category_type = CONFIGURE_CATEGORY_CTRL_NUM;
-	}
 
-	for( i = 0 ; i < category_type ; i++ )
-	{
-		if( (*configure_info)->info[i] )
-		{
-			g_print( "[ConfigureInfo] : Category [%d]\n", i );
-			for( j = 0 ; j < (*configure_info)->info[i]->count ; j++ )
-			{
-				if( _mmcamcorder_conf_get_value_type(handle, (*configure_info)->type, i, ((type_int*)((*configure_info)->info[i]->detail_info[j]))->name, &type ) )
-				{
-					switch( type )
-					{
-						case CONFIGURE_VALUE_INT:
-							temp_int = (type_int*)((*configure_info)->info[i]->detail_info[j]);
-							g_print( "[ConfigureInfo] : INT - Name[%s],Value [%d]\n", temp_int->name, temp_int->value );
-							break;
-						case CONFIGURE_VALUE_INT_RANGE:
-							temp_int_range = (type_int_range*)((*configure_info)->info[i]->detail_info[j]);
-							g_print( "[ConfigureInfo] : INT_RANGE - Name[%s],Value [%d]~[%d], default [%d]\n",
-							         temp_int_range->name, temp_int_range->min, temp_int_range->max, temp_int_range->default_value );
-							break;
-						case CONFIGURE_VALUE_INT_ARRAY:
-							temp_int_array = (type_int_array*)((*configure_info)->info[i]->detail_info[j]);
-							g_print( "[ConfigureInfo] : INT_ARRAY - Name[%s], default [%d]\n                            - ",
-							         temp_int_array->name, temp_int_array->default_value );
-							for( k = 0 ; k < temp_int_array->count ; k++ )
-							{
-								g_print( "[%d] ", temp_int_array->value[k] );
-							}
-							g_print( "\n" );
-							break;
-						case CONFIGURE_VALUE_INT_PAIR_ARRAY:
-							temp_int_pair_array = (type_int_pair_array*)((*configure_info)->info[i]->detail_info[j]);
-							g_print( "[ConfigureInfo] : INT_PAIR_ARRAY - Name[%s], default [%d][%d]\n                            - ",
-							         temp_int_pair_array->name, temp_int_pair_array->default_value[0], temp_int_pair_array->default_value[0] );
-							for( k = 0 ; k < temp_int_pair_array->count ; k++ )
-							{
-								g_print( "[%d,%d] ", temp_int_pair_array->value[0][k], temp_int_pair_array->value[1][k] );
-							}
-							g_print( "\n" );
-							break;
-						case CONFIGURE_VALUE_STRING:
-							temp_string = (type_string*)((*configure_info)->info[i]->detail_info[j]);
-							g_print( "[ConfigureInfo] : STRING - Name[%s],Value[%s]\n", temp_string->name, temp_string->value );
-							break;
-						case CONFIGURE_VALUE_ELEMENT:
-							temp_element = (type_element*)((*configure_info)->info[i]->detail_info[j]);
-							g_print( "[ConfigureInfo] : Element - Name[%s],Element_Name[%s]\n", temp_element->name, temp_element->element_name );
-							for( k = 0 ; k < temp_element->count_int ; k++ )
-							{
-								g_print( "                          - INT[%d] Name[%s],Value[%d]\n", k, temp_element->value_int[k]->name, temp_element->value_int[k]->value );
-							}
-							for( k = 0 ; k < temp_element->count_string ; k++ )
-							{
-								g_print( "                          - STRING[%d] Name[%s],Value[%s]\n", k, temp_element->value_string[k]->name, temp_element->value_string[k]->value );
-							}
-							break;
-						default:
-							g_print( "[ConfigureInfo] : Not matched value type... So can not print data... check it... Name[%s],type[%d]\n", ((type_int*)((*configure_info)->info[i]->detail_info[j]))->name, type );
-							break;
+	for (i = 0 ; i < category_type ; i++) {
+
+		if ((*configure_info)->info[i]) {
+			g_print("[ConfigureInfo] : Category [%d]\n", i);
+
+			for (j = 0 ; j < (*configure_info)->info[i]->count ; j++) {
+
+				if (_mmcamcorder_conf_get_value_type(handle, (*configure_info)->type, i, ((type_int*)((*configure_info)->info[i]->detail_info[j]))->name, &type)) {
+					switch (type) {
+					case CONFIGURE_VALUE_INT:
+						temp_int = (type_int*)((*configure_info)->info[i]->detail_info[j]);
+						g_print("[ConfigureInfo] : INT - Name[%s],Value [%d]\n", temp_int->name, temp_int->value);
+						break;
+					case CONFIGURE_VALUE_INT_RANGE:
+						temp_int_range = (type_int_range*)((*configure_info)->info[i]->detail_info[j]);
+						g_print("[ConfigureInfo] : INT_RANGE - Name[%s],Value [%d]~[%d], default [%d]\n",
+							temp_int_range->name, temp_int_range->min, temp_int_range->max, temp_int_range->default_value);
+						break;
+					case CONFIGURE_VALUE_INT_ARRAY:
+						temp_int_array = (type_int_array*)((*configure_info)->info[i]->detail_info[j]);
+						g_print("[ConfigureInfo] : INT_ARRAY - Name[%s], default [%d]\n                            - ",
+							temp_int_array->name, temp_int_array->default_value);
+
+						for (k = 0 ; k < temp_int_array->count ; k++)
+							g_print("[%d] ", temp_int_array->value[k]);
+
+						g_print("\n");
+						break;
+					case CONFIGURE_VALUE_INT_PAIR_ARRAY:
+						temp_int_pair_array = (type_int_pair_array*)((*configure_info)->info[i]->detail_info[j]);
+						g_print("[ConfigureInfo] : INT_PAIR_ARRAY - Name[%s], default [%d][%d]\n                            - ",
+							temp_int_pair_array->name, temp_int_pair_array->default_value[0], temp_int_pair_array->default_value[0]);
+
+						for (k = 0 ; k < temp_int_pair_array->count ; k++)
+							g_print("[%d,%d] ", temp_int_pair_array->value[0][k], temp_int_pair_array->value[1][k]);
+
+						g_print("\n");
+						break;
+					case CONFIGURE_VALUE_STRING:
+						temp_string = (type_string*)((*configure_info)->info[i]->detail_info[j]);
+						g_print("[ConfigureInfo] : STRING - Name[%s],Value[%s]\n", temp_string->name, temp_string->value);
+						break;
+					case CONFIGURE_VALUE_ELEMENT:
+						temp_element = (type_element*)((*configure_info)->info[i]->detail_info[j]);
+						g_print("[ConfigureInfo] : Element - Name[%s],Element_Name[%s]\n", temp_element->name, temp_element->element_name);
+
+						for (k = 0 ; k < temp_element->count_int ; k++)
+							g_print("                          - INT[%d] Name[%s],Value[%d]\n", k, temp_element->value_int[k]->name, temp_element->value_int[k]->value);
+
+						for (k = 0 ; k < temp_element->count_string ; k++)
+							g_print("                          - STRING[%d] Name[%s],Value[%s]\n", k, temp_element->value_string[k]->name, temp_element->value_string[k]->value);
+
+						break;
+					default:
+						g_print("[ConfigureInfo] : Not matched value type... So can not print data... check it... Name[%s],type[%d]\n", ((type_int*)((*configure_info)->info[i]->detail_info[j]))->name, type);
+						break;
 					}
-				}
-				else
-				{
-					g_print( "[ConfigureInfo] : Failed to get value type." );
+				} else {
+					g_print("[ConfigureInfo] : Failed to get value type.");
 				}
 			}
 		}
 	}
 
-	g_print( "[ConfigureInfoPrint] : Done.\n" );
+	g_print("[ConfigureInfoPrint] : Done.\n");
 }
 
 
@@ -2420,7 +2269,7 @@ __mmcamcorder_get_audio_codec_element(MMHandleType handle)
 	type_element *telement = NULL;
 	const char *codec_type_str = NULL;
 	int codec_type = MM_AUDIO_CODEC_INVALID;
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
 
 	mmf_return_val_if_fail(hcamcorder, NULL);
@@ -2433,47 +2282,46 @@ __mmcamcorder_get_audio_codec_element(MMHandleType handle)
 	/* Check element availability */
 	mm_camcorder_get_attributes(handle, NULL, MMCAM_AUDIO_ENCODER, &codec_type, NULL);
 
-	switch( codec_type )
-	{
-		case MM_AUDIO_CODEC_AMR:
-			codec_type_str = "AMR";
-			break;
-		case MM_AUDIO_CODEC_G723_1:
-			codec_type_str = "G723_1";
-			break;
-		case MM_AUDIO_CODEC_MP3:
-			codec_type_str = "MP3";
-			break;
-		case MM_AUDIO_CODEC_AAC:
-			codec_type_str = "AAC";
-			break;
-		case MM_AUDIO_CODEC_MMF:
-			codec_type_str = "MMF";
-			break;
-		case MM_AUDIO_CODEC_ADPCM:
-			codec_type_str = "ADPCM";
-			break;
-		case MM_AUDIO_CODEC_WAVE:
-			codec_type_str = "WAVE";
-			break;
-		case MM_AUDIO_CODEC_MIDI:
-			codec_type_str = "MIDI";
-			break;
-		case MM_AUDIO_CODEC_IMELODY:
-			codec_type_str = "IMELODY";
-			break;
-		case MM_AUDIO_CODEC_VORBIS:
-			codec_type_str = "VORBIS";
-			break;
-		default:
-			_mmcam_dbg_err( "Not supported audio codec[%d]", codec_type );
-			return NULL;
+	switch (codec_type) {
+	case MM_AUDIO_CODEC_AMR:
+		codec_type_str = "AMR";
+		break;
+	case MM_AUDIO_CODEC_G723_1:
+		codec_type_str = "G723_1";
+		break;
+	case MM_AUDIO_CODEC_MP3:
+		codec_type_str = "MP3";
+		break;
+	case MM_AUDIO_CODEC_AAC:
+		codec_type_str = "AAC";
+		break;
+	case MM_AUDIO_CODEC_MMF:
+		codec_type_str = "MMF";
+		break;
+	case MM_AUDIO_CODEC_ADPCM:
+		codec_type_str = "ADPCM";
+		break;
+	case MM_AUDIO_CODEC_WAVE:
+		codec_type_str = "WAVE";
+		break;
+	case MM_AUDIO_CODEC_MIDI:
+		codec_type_str = "MIDI";
+		break;
+	case MM_AUDIO_CODEC_IMELODY:
+		codec_type_str = "IMELODY";
+		break;
+	case MM_AUDIO_CODEC_VORBIS:
+		codec_type_str = "VORBIS";
+		break;
+	default:
+		_mmcam_dbg_err("Not supported audio codec[%d]", codec_type);
+		return NULL;
 	}
 
 	_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-				      CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER,
-				      codec_type_str,
-				      &telement);
+		CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER,
+		codec_type_str,
+		&telement);
 
 	return telement;
 }
@@ -2485,7 +2333,7 @@ __mmcamcorder_get_video_codec_element(MMHandleType handle)
 	type_element *telement = NULL;
 	const char *codec_type_str = NULL;
 	int codec_type = MM_VIDEO_CODEC_INVALID;
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
 
 	mmf_return_val_if_fail(hcamcorder, NULL);
@@ -2498,35 +2346,34 @@ __mmcamcorder_get_video_codec_element(MMHandleType handle)
 	/* Check element availability */
 	mm_camcorder_get_attributes(handle, NULL, MMCAM_VIDEO_ENCODER, &codec_type, NULL);
 
-	switch( codec_type )
-	{
-		case MM_VIDEO_CODEC_H263:
-			codec_type_str = "H263";
-			break;
-		case MM_VIDEO_CODEC_H264:
-			codec_type_str = "H264";
-			break;
-		case MM_VIDEO_CODEC_H26L:
-			codec_type_str = "H26L";
-			break;
-		case MM_VIDEO_CODEC_MPEG4:
-			codec_type_str = "MPEG4";
-			break;
-		case MM_VIDEO_CODEC_MPEG1:
-			codec_type_str = "MPEG1";
-			break;
-		case MM_VIDEO_CODEC_THEORA:
-			codec_type_str = "THEORA";
-			break;
-		default:
-			_mmcam_dbg_err( "Not supported video codec[%d]", codec_type );
-			return NULL;
+	switch (codec_type) {
+	case MM_VIDEO_CODEC_H263:
+		codec_type_str = "H263";
+		break;
+	case MM_VIDEO_CODEC_H264:
+		codec_type_str = "H264";
+		break;
+	case MM_VIDEO_CODEC_H26L:
+		codec_type_str = "H26L";
+		break;
+	case MM_VIDEO_CODEC_MPEG4:
+		codec_type_str = "MPEG4";
+		break;
+	case MM_VIDEO_CODEC_MPEG1:
+		codec_type_str = "MPEG1";
+		break;
+	case MM_VIDEO_CODEC_THEORA:
+		codec_type_str = "THEORA";
+		break;
+	default:
+		_mmcam_dbg_err("Not supported video codec[%d]", codec_type);
+		return NULL;
 	}
 
 	_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-				      CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER,
-				      codec_type_str,
-				      &telement);
+		CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER,
+		codec_type_str,
+		&telement);
 
 	return telement;
 }
@@ -2538,7 +2385,7 @@ __mmcamcorder_get_image_codec_element(MMHandleType handle)
 	type_element *telement = NULL;
 	const char *codec_type_str = NULL;
 	int codec_type = MM_IMAGE_CODEC_INVALID;
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
 
 	mmf_return_val_if_fail(hcamcorder, NULL);
@@ -2551,59 +2398,58 @@ __mmcamcorder_get_image_codec_element(MMHandleType handle)
 	/* Check element availability */
 	mm_camcorder_get_attributes(handle, NULL, MMCAM_IMAGE_ENCODER, &codec_type, NULL);
 
-	switch( codec_type )
-	{
-		case MM_IMAGE_CODEC_JPEG:
-			codec_type_str = "JPEG";
-			break;
-		case MM_IMAGE_CODEC_SRW:
-			codec_type_str = "SRW";
-			break;
-		case MM_IMAGE_CODEC_JPEG_SRW:
-			codec_type_str = "JPEG_SRW";
-			break;
-		case MM_IMAGE_CODEC_PNG:
-			codec_type_str = "PNG";
-			break;
-		case MM_IMAGE_CODEC_BMP:
-			codec_type_str = "BMP";
-			break;
-		case MM_IMAGE_CODEC_WBMP:
-			codec_type_str = "WBMP";
-			break;
-		case MM_IMAGE_CODEC_TIFF:
-			codec_type_str = "TIFF";
-			break;
-		case MM_IMAGE_CODEC_PCX:
-			codec_type_str = "PCX";
-			break;
-		case MM_IMAGE_CODEC_GIF:
-			codec_type_str = "GIF";
-			break;
-		case MM_IMAGE_CODEC_ICO:
-			codec_type_str = "ICO";
-			break;
-		case MM_IMAGE_CODEC_RAS:
-			codec_type_str = "RAS";
-			break;
-		case MM_IMAGE_CODEC_TGA:
-			codec_type_str = "TGA";
-			break;
-		case MM_IMAGE_CODEC_XBM:
-			codec_type_str = "XBM";
-			break;
-		case MM_IMAGE_CODEC_XPM:
-			codec_type_str = "XPM";
-			break;
-		default:
-			_mmcam_dbg_err( "Not supported image codec[%d]", codec_type );
-			return NULL;
+	switch (codec_type) {
+	case MM_IMAGE_CODEC_JPEG:
+		codec_type_str = "JPEG";
+		break;
+	case MM_IMAGE_CODEC_SRW:
+		codec_type_str = "SRW";
+		break;
+	case MM_IMAGE_CODEC_JPEG_SRW:
+		codec_type_str = "JPEG_SRW";
+		break;
+	case MM_IMAGE_CODEC_PNG:
+		codec_type_str = "PNG";
+		break;
+	case MM_IMAGE_CODEC_BMP:
+		codec_type_str = "BMP";
+		break;
+	case MM_IMAGE_CODEC_WBMP:
+		codec_type_str = "WBMP";
+		break;
+	case MM_IMAGE_CODEC_TIFF:
+		codec_type_str = "TIFF";
+		break;
+	case MM_IMAGE_CODEC_PCX:
+		codec_type_str = "PCX";
+		break;
+	case MM_IMAGE_CODEC_GIF:
+		codec_type_str = "GIF";
+		break;
+	case MM_IMAGE_CODEC_ICO:
+		codec_type_str = "ICO";
+		break;
+	case MM_IMAGE_CODEC_RAS:
+		codec_type_str = "RAS";
+		break;
+	case MM_IMAGE_CODEC_TGA:
+		codec_type_str = "TGA";
+		break;
+	case MM_IMAGE_CODEC_XBM:
+		codec_type_str = "XBM";
+		break;
+	case MM_IMAGE_CODEC_XPM:
+		codec_type_str = "XPM";
+		break;
+	default:
+		_mmcam_dbg_err("Not supported image codec[%d]", codec_type);
+		return NULL;
 	}
 
 	_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-				      CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER,
-				      codec_type_str,
-				      &telement);
+		CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER,
+		codec_type_str,
+		&telement);
 
 	return telement;
 }
@@ -2615,7 +2461,7 @@ __mmcamcorder_get_file_format_element(MMHandleType handle)
 	type_element *telement = NULL;
 	const char *mux_type_str = NULL;
 	int file_type = MM_FILE_FORMAT_INVALID;
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
 
 	mmf_return_val_if_fail(hcamcorder, NULL);
@@ -2628,59 +2474,58 @@ __mmcamcorder_get_file_format_element(MMHandleType handle)
 	/* Check element availability */
 	mm_camcorder_get_attributes(handle, NULL, MMCAM_FILE_FORMAT, &file_type, NULL);
 
-	switch( file_type )
-	{
-		case MM_FILE_FORMAT_3GP:
-			mux_type_str = "3GP";
-			break;
-		case MM_FILE_FORMAT_AMR:
-			mux_type_str = "AMR";
-			break;
-		case MM_FILE_FORMAT_MP4:
-			mux_type_str = "MP4";
-			break;
-		case MM_FILE_FORMAT_AAC:
-			mux_type_str = "AAC";
-			break;
-		case MM_FILE_FORMAT_MP3:
-			mux_type_str = "MP3";
-			break;
-		case MM_FILE_FORMAT_OGG:
-			mux_type_str = "OGG";
-			break;
-		case MM_FILE_FORMAT_WAV:
-			mux_type_str = "WAV";
-			break;
-		case MM_FILE_FORMAT_AVI:
-			mux_type_str = "AVI";
-			break;
-		case MM_FILE_FORMAT_WMA:
-			mux_type_str = "WMA";
-			break;
-		case MM_FILE_FORMAT_WMV:
-			mux_type_str = "WMV";
-			break;
-		case MM_FILE_FORMAT_MID:
-			mux_type_str = "MID";
-			break;
-		case MM_FILE_FORMAT_MMF:
-			mux_type_str = "MMF";
-			break;
-		case MM_FILE_FORMAT_MATROSKA:
-			mux_type_str = "MATROSKA";
-			break;
-		case MM_FILE_FORMAT_M2TS:
-			mux_type_str = "M2TS";
-			break;
-		default:
-			_mmcam_dbg_err( "Not supported file format[%d]", file_type );
-			return NULL;
+	switch (file_type) {
+	case MM_FILE_FORMAT_3GP:
+		mux_type_str = "3GP";
+		break;
+	case MM_FILE_FORMAT_AMR:
+		mux_type_str = "AMR";
+		break;
+	case MM_FILE_FORMAT_MP4:
+		mux_type_str = "MP4";
+		break;
+	case MM_FILE_FORMAT_AAC:
+		mux_type_str = "AAC";
+		break;
+	case MM_FILE_FORMAT_MP3:
+		mux_type_str = "MP3";
+		break;
+	case MM_FILE_FORMAT_OGG:
+		mux_type_str = "OGG";
+		break;
+	case MM_FILE_FORMAT_WAV:
+		mux_type_str = "WAV";
+		break;
+	case MM_FILE_FORMAT_AVI:
+		mux_type_str = "AVI";
+		break;
+	case MM_FILE_FORMAT_WMA:
+		mux_type_str = "WMA";
+		break;
+	case MM_FILE_FORMAT_WMV:
+		mux_type_str = "WMV";
+		break;
+	case MM_FILE_FORMAT_MID:
+		mux_type_str = "MID";
+		break;
+	case MM_FILE_FORMAT_MMF:
+		mux_type_str = "MMF";
+		break;
+	case MM_FILE_FORMAT_MATROSKA:
+		mux_type_str = "MATROSKA";
+		break;
+	case MM_FILE_FORMAT_M2TS:
+		mux_type_str = "M2TS";
+		break;
+	default:
+		_mmcam_dbg_err("Not supported file format[%d]", file_type);
+		return NULL;
 	}
 
 	_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-				      CONFIGURE_CATEGORY_MAIN_MUX,
-				      mux_type_str,
-				      &telement);
+		CONFIGURE_CATEGORY_MAIN_MUX,
+		mux_type_str,
+		&telement);
 
 	return telement;
 }
@@ -2693,22 +2538,21 @@ _mmcamcorder_get_type_element(MMHandleType handle, int type)
 
 	_mmcam_dbg_log("type:%d", type);
 
-	switch(type)
-	{
-		case MM_CAM_AUDIO_ENCODER:
-			telement = __mmcamcorder_get_audio_codec_element(handle);
-			break;
-		case MM_CAM_VIDEO_ENCODER:
-			telement = __mmcamcorder_get_video_codec_element(handle);
-			break;
-		case MM_CAM_IMAGE_ENCODER:
-			telement = __mmcamcorder_get_image_codec_element(handle);
-			break;
-		case MM_CAM_FILE_FORMAT:
-			telement = __mmcamcorder_get_file_format_element(handle);
-			break;
-		default :
-			_mmcam_dbg_log("Can't get element type form this profile.(%d)", type);
+	switch (type) {
+	case MM_CAM_AUDIO_ENCODER:
+		telement = __mmcamcorder_get_audio_codec_element(handle);
+		break;
+	case MM_CAM_VIDEO_ENCODER:
+		telement = __mmcamcorder_get_video_codec_element(handle);
+		break;
+	case MM_CAM_IMAGE_ENCODER:
+		telement = __mmcamcorder_get_image_codec_element(handle);
+		break;
+	case MM_CAM_FILE_FORMAT:
+		telement = __mmcamcorder_get_file_format_element(handle);
+		break;
+	default:
+		_mmcam_dbg_log("Can't get element type form this profile.(%d)", type);
 	}
 
 	return telement;
@@ -2861,7 +2705,6 @@ int _mmcamcorder_get_mux_format(MMHandleType handle, const char *name)
 		mux_index = MM_FILE_FORMAT_MATROSKA;
 	} else if (!strcmp(name, "M2TS")) {
 		mux_index = MM_FILE_FORMAT_M2TS;
-
 	}
 
 	/*_mmcam_dbg_log("mux index %d", mux_index);*/
@@ -2877,22 +2720,21 @@ _mmcamcorder_get_format(MMHandleType handle, int conf_category, const char *name
 
 	mmf_return_val_if_fail(name, -1);
 
-	switch(conf_category)
-	{
-		case CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER:
-			fmt = _mmcamcorder_get_audio_codec_format(handle, name);
-			break;
-		case CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER:
-			fmt = _mmcamcorder_get_video_codec_format(handle, name);
-			break;
-		case CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER:
-			fmt = _mmcamcorder_get_image_codec_format(handle, name);
-			break;
-		case CONFIGURE_CATEGORY_MAIN_MUX:
-			fmt = _mmcamcorder_get_mux_format(handle, name);
-			break;
-		default :
-			_mmcam_dbg_log("Can't get format from this category.(%d)", conf_category);
+	switch (conf_category) {
+	case CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER:
+		fmt = _mmcamcorder_get_audio_codec_format(handle, name);
+		break;
+	case CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER:
+		fmt = _mmcamcorder_get_video_codec_format(handle, name);
+		break;
+	case CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER:
+		fmt = _mmcamcorder_get_image_codec_format(handle, name);
+		break;
+	case CONFIGURE_CATEGORY_MAIN_MUX:
+		fmt = _mmcamcorder_get_mux_format(handle, name);
+		break;
+	default:
+		_mmcam_dbg_log("Can't get format from this category.(%d)", conf_category);
 	}
 
 	return fmt;
@@ -2901,7 +2743,7 @@ _mmcamcorder_get_format(MMHandleType handle, int conf_category, const char *name
 int
 _mmcamcorder_get_available_format(MMHandleType handle, int conf_category, int ** format)
 {
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	camera_conf* configure_info = NULL;
 	int *arr = NULL;
 	int total_count = 0;
@@ -2921,9 +2763,8 @@ _mmcamcorder_get_available_format(MMHandleType handle, int conf_category, int **
 
 		/*_mmcam_dbg_log("count[%d], info[%p]", count, info);*/
 
-		if (count <= 0 || !info) {
+		if (count <= 0 || !info)
 			return total_count;
-		}
 
 		arr = (int*) g_malloc0(count * sizeof(int));
 		if (arr == NULL) {
@@ -2932,15 +2773,13 @@ _mmcamcorder_get_available_format(MMHandleType handle, int conf_category, int **
 		}
 
 		for (i = 0 ; i < count ; i++) {
-			if (info->detail_info[i] == NULL) {
+			if (info->detail_info[i] == NULL)
 				continue;
-			}
 
 			name = ((type_element*)(info->detail_info[i]))->name;
 			fmt = _mmcamcorder_get_format(handle, conf_category, name);
-			if (fmt >= 0) {
+			if (fmt >= 0)
 				arr[total_count++] = fmt;
-			}
 
 			/*_mmcam_dbg_log("name:%s, fmt:%d", name, fmt);*/
 		}
diff --git a/src/mm_camcorder_exifinfo.c b/src/mm_camcorder_exifinfo.c
index a8975b5..50e5463 100644
--- a/src/mm_camcorder_exifinfo.c
+++ b/src/mm_camcorder_exifinfo.c
@@ -49,26 +49,25 @@
  */
 #include <string.h>
 #define _EXIF_BIN_SIZE_		((unsigned int)174)
-unsigned char g_exif_bin [_EXIF_BIN_SIZE_] = {
-   0x45 , 0x78 , 0x69 , 0x66 , 0x00 , 0x00 , 0x49 , 0x49 , 0x2a , 0x00 , 0x08 , 0x00 , 0x00 , 0x00 , 0x05 , 0x00
- , 0x1a , 0x01 , 0x05 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x4a , 0x00 , 0x00 , 0x00 , 0x1b , 0x01 , 0x05 , 0x00
- , 0x01 , 0x00 , 0x00 , 0x00 , 0x52 , 0x00 , 0x00 , 0x00 , 0x28 , 0x01 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00
- , 0x02 , 0x00 , 0x00 , 0x00 , 0x13 , 0x02 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00
- , 0x69 , 0x87 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x5a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
- , 0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00
- , 0x06 , 0x00 , 0x00 , 0x90 , 0x07 , 0x00 , 0x04 , 0x00 , 0x00 , 0x00 , 0x30 , 0x32 , 0x31 , 0x30 , 0x01 , 0x91
- , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0xa0 , 0x07 , 0x00 , 0x04 , 0x00
- , 0x00 , 0x00 , 0x30 , 0x31 , 0x30 , 0x30 , 0x01 , 0xa0 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
- , 0x00 , 0x00 , 0x02 , 0xa0 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x03 , 0xa0
- , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
+unsigned char g_exif_bin[_EXIF_BIN_SIZE_] = {
+	0x45 , 0x78 , 0x69 , 0x66 , 0x00 , 0x00 , 0x49 , 0x49 , 0x2a , 0x00 , 0x08 , 0x00 , 0x00 , 0x00 , 0x05 , 0x00 ,
+	0x1a , 0x01 , 0x05 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x4a , 0x00 , 0x00 , 0x00 , 0x1b , 0x01 , 0x05 , 0x00 ,
+	0x01 , 0x00 , 0x00 , 0x00 , 0x52 , 0x00 , 0x00 , 0x00 , 0x28 , 0x01 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 ,
+	0x02 , 0x00 , 0x00 , 0x00 , 0x13 , 0x02 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 ,
+	0x69 , 0x87 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x5a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 ,
+	0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 ,
+	0x06 , 0x00 , 0x00 , 0x90 , 0x07 , 0x00 , 0x04 , 0x00 , 0x00 , 0x00 , 0x30 , 0x32 , 0x31 , 0x30 , 0x01 , 0x91 ,
+	0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0xa0 , 0x07 , 0x00 , 0x04 , 0x00 ,
+	0x00 , 0x00 , 0x30 , 0x31 , 0x30 , 0x30 , 0x01 , 0xa0 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 ,
+	0x00 , 0x00 , 0x02 , 0xa0 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x03 , 0xa0 ,
+	0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
 };
 #endif
 
 /**
  * Structure for exif entry.
  */
-typedef struct  _mm_exif_entry_t
-{
+typedef struct  _mm_exif_entry_t {
 	ExifTag			tag;			/**< exif tag*/
 	ExifFormat		format;			/**< exif format*/
 	unsigned long	components;		/**< number of components*/
@@ -81,7 +80,7 @@ typedef struct  _mm_exif_entry_t
  * local functions.
  */
 static void
-_exif_set_uint16 (int is_motorola, void * out, unsigned short in)
+_exif_set_uint16(int is_motorola, void * out, unsigned short in)
 {
 	if (is_motorola) {
 		((unsigned char *)out)[0] = in & 0x00ff;
@@ -95,13 +94,13 @@ _exif_set_uint16 (int is_motorola, void * out, unsigned short in)
 
 #ifdef _MMCAMCORDER_EXIF_GET_JPEG_MARKER_OFFSET
 static unsigned long
-_exif_get_jpeg_marker_offset (void *jpeg, int jpeg_size, unsigned short marker)
+_exif_get_jpeg_marker_offset(void *jpeg, int jpeg_size, unsigned short marker)
 {
-	unsigned char	*p = NULL;
-	unsigned char	*src = jpeg;
-	int				src_sz = jpeg_size;
-	unsigned char	m[2];
-	unsigned long	ret;
+	unsigned char *p = NULL;
+	unsigned char *src = jpeg;
+	int src_sz = jpeg_size;
+	unsigned char m[2];
+	unsigned long ret;
 	int i;
 
 	m[0] = marker >> 8;
@@ -109,25 +108,19 @@ _exif_get_jpeg_marker_offset (void *jpeg, int jpeg_size, unsigned short marker)
 
 	_mmcam_dbg_log("marker: 0x%02X 0x%02X", m[0], m[1]);
 
-	if (*src == 0xff && *(src + 1) == 0xd8)
-	{
+	if (*src == 0xff && *(src + 1) == 0xd8) {
 		p = src + 2; /* SOI(start of image) */
-	}
-	else
-	{
+	} else {
 		_mmcam_dbg_log("invalid JPEG file.");
 		return 0UL;
 	}
 
-	for (i = 0; i < src_sz - (1 + 2); i++, p++)
-	{
-		if (*p == 0xff)
-		{
+	for (i = 0; i < src_sz - (1 + 2); i++, p++) {
+		if (*p == 0xff) {
 			/*marker is 0xFFxx*/
-			if (*(p + 1) == m[1])
-			{
+			if (*(p + 1) == m[1]) {
 				ret = p - src;
-				_mmcam_dbg_log("marker offset: %lu %p %p.",ret, (p+1), src);
+				_mmcam_dbg_log("marker offset: %lu %p %p.", ret, (p+1), src);
 				return ret;
 			}
 		}
@@ -139,68 +132,63 @@ _exif_get_jpeg_marker_offset (void *jpeg, int jpeg_size, unsigned short marker)
 
 
 ExifData*
-mm_exif_get_exif_data_from_data (mm_exif_info_t *info)
+mm_exif_get_exif_data_from_data(mm_exif_info_t *info)
 {
-	ExifData 		*ed = NULL;
+	ExifData *ed = NULL;
 
 	ed = exif_data_new_from_data(info->data, info->size);
-	if( ed == NULL )
-	{
+	if (ed == NULL)
 		_mmcam_dbg_log("Null exif data. (ed:%p)", ed);
-	}
 
 	return ed;
 }
 
 
 ExifData*
-mm_exif_get_exif_from_info (mm_exif_info_t *info)
+mm_exif_get_exif_from_info(mm_exif_info_t *info)
 {
-	ExifData 		*ed = NULL;
-	ExifLoader		*loader = NULL;
+	ExifData *ed = NULL;
+	ExifLoader *loader = NULL;
 
-	unsigned char	size[2];
-	unsigned int	i;
+	unsigned char size[2];
+	unsigned int i;
 
 	/*get ExifData from info*/
-	loader = exif_loader_new ();
+	loader = exif_loader_new();
 
 	size[0] = (unsigned char) (info->size);
 	size[1] = (unsigned char) (info->size >> 8);
-	exif_loader_write (loader, size, 2);
+	exif_loader_write(loader, size, 2);
 
-	for (i = 0; i < info->size && exif_loader_write (loader, info->data + i, 1); i++);
+	for (i = 0; i < info->size && exif_loader_write(loader, info->data + i, 1); i++);
 
-	ed = exif_loader_get_data (loader);
-	exif_loader_unref (loader);
+	ed = exif_loader_get_data(loader);
+	exif_loader_unref(loader);
 	return ed;
 }
 
 
 int
-mm_exif_set_exif_to_info (mm_exif_info_t *info, ExifData *exif)
+mm_exif_set_exif_to_info(mm_exif_info_t *info, ExifData *exif)
 {
-	unsigned char	*eb = NULL;
-	unsigned int	ebs;
+	unsigned char *eb = NULL;
+	unsigned int ebs;
 
-	if (!exif)
-	{
+	if (!exif) {
 		_mmcam_dbg_log("exif Null");
 		return MM_ERROR_CAMCORDER_NOT_INITIALIZED;
 	}
 
 	_mmcam_dbg_log("exif(ifd :%p)", exif->ifd);
 
-	if(info->data)
-	{
-		free (info->data);
+	if (info->data) {
+		free(info->data);
 		info->data = NULL;
 		info->size = 0;
 	}
 
-	exif_data_save_data (exif, &eb, &ebs);
-	if(eb==NULL)
-	{
+	exif_data_save_data(exif, &eb, &ebs);
+	if (eb == NULL) {
 		_mmcam_dbg_log("MM_ERROR_CAMCORDER_LOW_MEMORY");
 		return MM_ERROR_CAMCORDER_LOW_MEMORY;
 	}
@@ -211,14 +199,14 @@ mm_exif_set_exif_to_info (mm_exif_info_t *info, ExifData *exif)
 
 
 int
-mm_exif_set_add_entry (ExifData *exif, ExifIfd ifd, ExifTag tag,ExifFormat format,unsigned long components, const char* data)
+mm_exif_set_add_entry(ExifData *exif, ExifIfd ifd, ExifTag tag, ExifFormat format, unsigned long components, const char* data)
 {
 	ExifData *ed = (ExifData *)exif;
 	ExifEntry *e = NULL;
 
 	if (exif == NULL || format <= 0 || components <= 0 || data == NULL) {
 		_mmcam_dbg_err("invalid argument exif=%p format=%d, components=%lu data=%p!",
-		                          exif,format,components,data);
+					   exif, format, components, data);
 		return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 	}
 
@@ -246,13 +234,12 @@ mm_exif_set_add_entry (ExifData *exif, ExifIfd ifd, ExifTag tag,ExifFormat forma
 			return MM_ERROR_CAMCORDER_LOW_MEMORY;
 		}
 
-		if (format == EXIF_FORMAT_ASCII) {
+		if (format == EXIF_FORMAT_ASCII)
 			memset(e->data, '\0', exif_format_get_size(format) * e->components);
-		}
 	}
 
 	e->size = exif_format_get_size(format) * e->components;
-	memcpy(e->data,data,e->size);
+	memcpy(e->data, data, e->size);
 	exif_content_add_entry(ed->ifd[ifd], e);
 	exif_entry_unref(e);
 
@@ -268,7 +255,7 @@ mm_exif_set_add_entry (ExifData *exif, ExifIfd ifd, ExifTag tag,ExifFormat forma
 
 
 int
-mm_exif_create_exif_info (mm_exif_info_t **info)
+mm_exif_create_exif_info(mm_exif_info_t **info)
 {
 	mm_exif_info_t *x = NULL;
 #if (MM_EXIFINFO_USE_BINARY_EXIFDATA == 0)
@@ -332,28 +319,28 @@ mm_exif_create_exif_info (mm_exif_info_t **info)
 }
 
 void
-mm_exif_destory_exif_info (mm_exif_info_t *info)
+mm_exif_destory_exif_info(mm_exif_info_t *info)
 {
-	//_mmcam_dbg_log( "");
+	/* _mmcam_dbg_log( ""); */
 
 #if MM_EXIFINFO_USE_BINARY_EXIFDATA
 	if (info) {
 		if (info->data)
-			free (info->data);
-		free (info);
+			free(info->data);
+		free(info);
 	}
 #else
 	if (info) {
 		if (info->data)
-			exif_mem_free (info->data);
-		free (info);
+			exif_mem_free(info->data);
+		free(info);
 	}
 #endif
 }
 
 
 int
-mm_exif_add_thumbnail_info (mm_exif_info_t *info, void *thumbnail, int width, int height, int len)
+mm_exif_add_thumbnail_info(mm_exif_info_t *info, void *thumbnail, int width, int height, int len)
 {
 	ExifData *ed = NULL;
 	static ExifLong elong[10];
@@ -364,8 +351,7 @@ mm_exif_add_thumbnail_info (mm_exif_info_t *info, void *thumbnail, int width, in
 
 	_mmcam_dbg_log("Thumbnail size:%d, width:%d, height:%d", len, width, height);
 
-	if( len > JPEG_THUMBNAIL_MAX_SIZE )
-	{
+	if (len > JPEG_THUMBNAIL_MAX_SIZE) {
 		_mmcam_dbg_err("Thumbnail size[%d] over!!! Skip inserting thumbnail...", len);
 		return MM_ERROR_NONE;
 	}
@@ -385,44 +371,42 @@ mm_exif_add_thumbnail_info (mm_exif_info_t *info, void *thumbnail, int width, in
 	if (p_compressed != NULL) {
 		exif_set_short(p_compressed, exif_data_get_byte_order(ed), 6);
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_1, EXIF_TAG_COMPRESSION, EXIF_FORMAT_SHORT, 1, (const char *)p_compressed);
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			goto exit;
-		}
 	} else {
 		ret = MM_ERROR_CAMCORDER_LOW_MEMORY;
 		goto exit;
 	}
 
 	/* set thumbnail size */
-	exif_set_long ((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), width);
+	exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), width);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_1, EXIF_TAG_IMAGE_WIDTH, EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		goto exit;
-	}
-	exif_set_long ((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), height);
+
+	exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), height);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_1, EXIF_TAG_IMAGE_LENGTH, EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		goto exit;
-	}
 
-	ret = mm_exif_set_exif_to_info (info, ed);
-	if (ret != MM_ERROR_NONE) {
+	ret = mm_exif_set_exif_to_info(info, ed);
+	if (ret != MM_ERROR_NONE)
 		goto exit;
-	}
 
 	ed->data = NULL;
 	ed->size = 0;
-	exif_data_unref (ed);
+	exif_data_unref(ed);
 
-exit :
-	if(p_compressed != NULL)
+exit:
+	if (p_compressed != NULL)
 		free(p_compressed);
+
 	return ret;
 }
 
 
 int
-mm_exif_write_exif_jpeg_to_file (char *filename, mm_exif_info_t *info,  void *jpeg, int jpeg_len)
+mm_exif_write_exif_jpeg_to_file(char *filename, mm_exif_info_t *info,  void *jpeg, int jpeg_len)
 {
 	FILE *fp = NULL;
 	unsigned short head[2] = {0,};
@@ -436,38 +420,37 @@ mm_exif_write_exif_jpeg_to_file (char *filename, mm_exif_info_t *info,  void *jp
 	ebs = info->size;
 
 	/*create file*/
-	fp = fopen (filename, "wb");
+	fp = fopen(filename, "wb");
 	if (!fp) {
-		_mmcam_dbg_err( "fopen() failed [%s].", filename);
+		_mmcam_dbg_err("fopen() failed [%s].", filename);
 		return MM_ERROR_IMAGE_FILEOPEN;
 	}
 
 	/*set SOI, APP1*/
-	_exif_set_uint16 (0, &head[0], 0xffd8);
-	_exif_set_uint16 (0, &head[1], 0xffe1);
+	_exif_set_uint16(0, &head[0], 0xffd8);
+	_exif_set_uint16(0, &head[1], 0xffe1);
 	/*set header length*/
-	_exif_set_uint16 (0, &head_len, (unsigned short)(ebs + 2));
+	_exif_set_uint16(0, &head_len, (unsigned short)(ebs + 2));
 
-	if(head[0]==0 || head[1]==0 || head_len==0)
-	{
+	if (head[0] == 0 || head[1] == 0 || head_len == 0) {
 		_mmcam_dbg_err("setting error");
-		fclose (fp);
+		fclose(fp);
 		return -1;
 	}
 
-	fwrite (&head[0], 1, EXIF_MARKER_SOI_LENGTH, fp);       /*SOI marker*/
-	fwrite (&head[1], 1, EXIF_MARKER_APP1_LENGTH, fp);      /*APP1 marker*/
-	fwrite (&head_len, 1, EXIF_APP1_LENGTH, fp);            /*length of APP1*/
-	fwrite (eb, 1, ebs, fp);                                /*EXIF*/
-	fwrite (jpeg + JPEG_DATA_OFFSET, 1, jpeg_len - JPEG_DATA_OFFSET, fp);   /*IMAGE*/
+	fwrite(&head[0], 1, EXIF_MARKER_SOI_LENGTH, fp);       /*SOI marker*/
+	fwrite(&head[1], 1, EXIF_MARKER_APP1_LENGTH, fp);      /*APP1 marker*/
+	fwrite(&head_len, 1, EXIF_APP1_LENGTH, fp);            /*length of APP1*/
+	fwrite(eb, 1, ebs, fp);                                /*EXIF*/
+	fwrite(jpeg + JPEG_DATA_OFFSET, 1, jpeg_len - JPEG_DATA_OFFSET, fp);   /*IMAGE*/
 
-	fclose (fp);
+	fclose(fp);
 
 	return MM_ERROR_NONE;
 }
 
 int
-mm_exif_write_exif_jpeg_to_memory (void **mem, unsigned int *length, mm_exif_info_t *info,  void *jpeg, unsigned int jpeg_len)
+mm_exif_write_exif_jpeg_to_memory(void **mem, unsigned int *length, mm_exif_info_t *info,  void *jpeg, unsigned int jpeg_len)
 {
 	unsigned short head[2] = {0,};
 	unsigned short head_len = 0;
@@ -482,15 +465,13 @@ mm_exif_write_exif_jpeg_to_memory (void **mem, unsigned int *length, mm_exif_inf
 
 	_mmcam_dbg_log("");
 
-	if(info==NULL || jpeg==NULL)
-	{
-		_mmcam_dbg_err( "MM_ERROR_CAMCORDER_INVALID_ARGUMENT info=%p, jpeg=%p",info,jpeg);
+	if (info == NULL || jpeg == NULL) {
+		_mmcam_dbg_err("MM_ERROR_CAMCORDER_INVALID_ARGUMENT info=%p, jpeg=%p", info, jpeg);
 		return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 	}
 
-	if(jpeg_len>JPEG_MAX_SIZE)
-	{
-		_mmcam_dbg_err( "jpeg_len is worng jpeg_len=%d",jpeg_len);
+	if (jpeg_len > JPEG_MAX_SIZE) {
+		_mmcam_dbg_err("jpeg_len is worng jpeg_len=%d", jpeg_len);
 		return MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG;
 	}
 
@@ -518,17 +499,17 @@ mm_exif_write_exif_jpeg_to_memory (void **mem, unsigned int *length, mm_exif_inf
 	/*SOI + APP1 + length of APP1 + length of EXIF + IMAGE*/
 	m_len = EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH + ebs + (jpeg_len - jpeg_offset);
 	/*alloc output image*/
-	m = malloc (m_len);
+	m = malloc(m_len);
 	if (!m) {
-		_mmcam_dbg_err( "malloc() failed.");
+		_mmcam_dbg_err("malloc() failed.");
 		return MM_ERROR_CAMCORDER_LOW_MEMORY;
 	}
 
 	/*set SOI, APP1*/
-	_exif_set_uint16 (0, &head[0], 0xffd8);
-	_exif_set_uint16 (0, &head[1], 0xffe1);
+	_exif_set_uint16(0, &head[0], 0xffd8);
+	_exif_set_uint16(0, &head[1], 0xffe1);
 	/*set header length*/
-	_exif_set_uint16 (0, &head_len, (unsigned short)(ebs + 2));
+	_exif_set_uint16(0, &head_len, (unsigned short)(ebs + 2));
 	if (head[0] == 0 || head[1] == 0 || head_len == 0) {
 		_mmcam_dbg_err("setting error");
 		free(m);
@@ -538,24 +519,25 @@ mm_exif_write_exif_jpeg_to_memory (void **mem, unsigned int *length, mm_exif_inf
 	/* Complete JPEG+EXIF */
 	/*SOI marker*/
 	memcpy(m, &head[0], EXIF_MARKER_SOI_LENGTH);
+
 	/*APP1 marker*/
-	memcpy(m + EXIF_MARKER_SOI_LENGTH,
-	       &head[1], EXIF_MARKER_APP1_LENGTH);
+	memcpy(m + EXIF_MARKER_SOI_LENGTH, &head[1], EXIF_MARKER_APP1_LENGTH);
+
 	/*length of APP1*/
-	memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH,
-	       &head_len, EXIF_APP1_LENGTH);
+	memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH, &head_len, EXIF_APP1_LENGTH);
+
 	/*EXIF*/
-	memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH,
-	       eb, ebs);
+	memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH, eb, ebs);
+
 	/*IMAGE*/
 	memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH + ebs,
-	       jpeg + jpeg_offset, jpeg_len - jpeg_offset);
+		jpeg + jpeg_offset, jpeg_len - jpeg_offset);
 
 	_mmcam_dbg_log("JPEG+EXIF Copy DONE(original:%d, offset:%d, copied:%d)",
-	                        jpeg_len, jpeg_offset, jpeg_len - jpeg_offset);
+		jpeg_len, jpeg_offset, jpeg_len - jpeg_offset);
 
 	/*set ouput param*/
-	*mem    = m;
+	*mem = m;
 	*length = m_len;
 
 	return MM_ERROR_NONE;
@@ -568,11 +550,13 @@ int mm_exif_load_exif_info(mm_exif_info_t **info, void *jpeg_data, int jpeg_leng
 	const unsigned char *b = NULL;
 	unsigned int s = 0;
 	mm_exif_info_t *x = NULL;
-	// TODO : get exif and re-set exif
+
+	/* TODO : get exif and re-set exif */
+
 	loader = exif_loader_new();
 	if (loader) {
-		exif_loader_write (loader, jpeg_data, jpeg_length);
-		exif_loader_get_buf (loader, &b, &s);
+		exif_loader_write(loader, jpeg_data, jpeg_length);
+		exif_loader_get_buf(loader, &b, &s);
 		if (s > 0) {
 			x = malloc(sizeof(mm_exif_info_t));
 			if (x) {
@@ -586,6 +570,7 @@ int mm_exif_load_exif_info(mm_exif_info_t **info, void *jpeg_data, int jpeg_leng
 					_mmcam_dbg_err("mm_exif_info_t malloc failed");
 					free(x);
 					exif_loader_unref(loader);
+
 					return MM_ERROR_CAMCORDER_LOW_MEMORY;
 				}
 			} else {
@@ -602,9 +587,8 @@ int mm_exif_load_exif_info(mm_exif_info_t **info, void *jpeg_data, int jpeg_leng
 		_mmcam_dbg_err("exif_loader_new failed");
 	}
 
-	if (x) {
+	if (x)
 		return MM_ERROR_NONE;
-	} else {
+	else
 		return MM_ERROR_CAMCORDER_INTERNAL;
-	}
 }
diff --git a/src/mm_camcorder_gstcommon.c b/src/mm_camcorder_gstcommon.c
index 5d4c8ba..914020e 100644
--- a/src/mm_camcorder_gstcommon.c
+++ b/src/mm_camcorder_gstcommon.c
@@ -38,8 +38,8 @@
 |    GLOBAL VARIABLE DEFINITIONS for internal				|
 -----------------------------------------------------------------------*/
 /* Table for compatibility between audio codec and file format */
-gboolean	audiocodec_fileformat_compatibility_table[MM_AUDIO_CODEC_NUM][MM_FILE_FORMAT_NUM] =
-{          /* 3GP ASF AVI MATROSKA MP4 OGG NUT QT REAL AMR AAC MP3 AIFF AU WAV MID MMF DIVX FLV VOB IMELODY WMA WMV JPG FLAC M2TS*/
+gboolean	audiocodec_fileformat_compatibility_table[MM_AUDIO_CODEC_NUM][MM_FILE_FORMAT_NUM] = {
+		   /* 3GP ASF AVI MATROSKA MP4 OGG NUT QT REAL AMR AAC MP3 AIFF AU WAV MID MMF DIVX FLV VOB IMELODY WMA WMV JPG FLAC M2TS*/
 /*AMR*/       { 1,  0,  0,       0,  0,  0,  0, 0,   0,  1,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
 /*G723.1*/    { 0,  0,  0,       0,  0,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
 /*MP3*/       { 0,  1,  1,       1,  1,  0,  0, 1,   0,  0,  0,  1,   0, 0,  0,  0,  0,   0,  1,  0,      0,  0,  0,  0,   0,   1},
@@ -87,8 +87,8 @@ gboolean	audiocodec_fileformat_compatibility_table[MM_AUDIO_CODEC_NUM][MM_FILE_F
 };
 
 /* Table for compatibility between video codec and file format */
-gboolean	videocodec_fileformat_compatibility_table[MM_VIDEO_CODEC_NUM][MM_FILE_FORMAT_NUM] =
-{             /* 3GP ASF AVI MATROSKA MP4 OGG NUT QT REAL AMR AAC MP3 AIFF AU WAV MID MMF DIVX FLV VOB IMELODY WMA WMV JPG FLAC M2TS*/
+gboolean	videocodec_fileformat_compatibility_table[MM_VIDEO_CODEC_NUM][MM_FILE_FORMAT_NUM] = {
+			  /* 3GP ASF AVI MATROSKA MP4 OGG NUT QT REAL AMR AAC MP3 AIFF AU WAV MID MMF DIVX FLV VOB IMELODY WMA WMV JPG FLAC M2TS*/
 /*NONE*/         { 0,  0,  0,       0,  0,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
 /*H263*/         { 1,  0,  1,       0,  0,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
 /*H264*/         { 1,  0,  1,       1,  1,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   1},
@@ -206,40 +206,40 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle)
 	/* Check existence */
 	for (i = _MMCAMCORDER_VIDEOSRC_SRC ; i <= _MMCAMCORDER_VIDEOSINK_SINK ; i++) {
 		if (sc->element[i].gst) {
-			if (((GObject *)sc->element[i].gst)->ref_count > 0) {
+			if (((GObject *)sc->element[i].gst)->ref_count > 0)
 				gst_object_unref(sc->element[i].gst);
-			}
+
 			_mmcam_dbg_log("element[index:%d] is Already existed.", i);
 		}
 	}
 
 	/* Get video device index info */
 	_mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl,
-	                                      CONFIGURE_CATEGORY_CTRL_CAMERA,
-	                                      "InputIndex",
-	                                      &input_index);
+										  CONFIGURE_CATEGORY_CTRL_CAMERA,
+										  "InputIndex",
+										  &input_index);
 	if (input_index == NULL) {
 		_mmcam_dbg_err("Failed to get input_index");
 		return MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
 	}
 
 	err = mm_camcorder_get_attributes(handle, &err_name,
-	                                  MMCAM_CAMERA_WIDTH, &camera_width,
-	                                  MMCAM_CAMERA_HEIGHT, &camera_height,
-	                                  MMCAM_CAMERA_FORMAT, &sc->info_image->preview_format,
-	                                  MMCAM_CAMERA_FPS, &fps,
-	                                  MMCAM_CAMERA_ROTATION, &camera_rotate,
-	                                  MMCAM_CAMERA_FLIP, &camera_flip,
-	                                  MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
-	                                  MMCAM_CAMERA_ANTI_HANDSHAKE, &anti_shake,
-	                                  MMCAM_CAPTURE_WIDTH, &capture_width,
-	                                  MMCAM_CAPTURE_HEIGHT, &capture_height,
-	                                  MMCAM_CAMERA_HDR_CAPTURE, &sc->info_image->hdr_capture_mode,
-	                                  MMCAM_IMAGE_ENCODER, &codectype,
-	                                  MMCAM_IMAGE_ENCODER_QUALITY, &capture_jpg_quality,
-	                                  MMCAM_DISPLAY_SOCKET_PATH, &socket_path, &socket_path_len,
-	                                  MMCAM_DISPLAY_SURFACE, &display_surface_type,
-	                                  NULL);
+		MMCAM_CAMERA_WIDTH, &camera_width,
+		MMCAM_CAMERA_HEIGHT, &camera_height,
+		MMCAM_CAMERA_FORMAT, &sc->info_image->preview_format,
+		MMCAM_CAMERA_FPS, &fps,
+		MMCAM_CAMERA_ROTATION, &camera_rotate,
+		MMCAM_CAMERA_FLIP, &camera_flip,
+		MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
+		MMCAM_CAMERA_ANTI_HANDSHAKE, &anti_shake,
+		MMCAM_CAPTURE_WIDTH, &capture_width,
+		MMCAM_CAPTURE_HEIGHT, &capture_height,
+		MMCAM_CAMERA_HDR_CAPTURE, &sc->info_image->hdr_capture_mode,
+		MMCAM_IMAGE_ENCODER, &codectype,
+		MMCAM_IMAGE_ENCODER_QUALITY, &capture_jpg_quality,
+		MMCAM_DISPLAY_SOCKET_PATH, &socket_path, &socket_path_len,
+		MMCAM_DISPLAY_SURFACE, &display_surface_type,
+		NULL);
 	if (err != MM_ERROR_NONE) {
 		_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
 		SAFE_FREE(err_name);
@@ -251,9 +251,9 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle)
 
 	/* Get videosrc element and its name from configure */
 	_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-	                              CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
-	                              "VideosrcElement",
-	                              &VideosrcElement);
+		CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+		"VideosrcElement",
+		&VideosrcElement);
 	_mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
 
 	/**
@@ -286,9 +286,8 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle)
 	/* set anti handshake mode */
 	_mmcamcorder_set_videosrc_anti_shake(handle, anti_shake);
 
-	if (sc->is_modified_rate) {
+	if (sc->is_modified_rate)
 		MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", fps);
-	}
 
 	/* Set basic infomation of videosrc element */
 	_mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, VideosrcElement);
@@ -433,7 +432,7 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle)
 
 	/* link elements */
 	if (!_mmcamcorder_link_elements(element_list)) {
-		_mmcam_dbg_err( "element link error." );
+		_mmcam_dbg_err("element link error.");
 		err = MM_ERROR_CAMCORDER_GST_LINK;
 		goto pipeline_creation_error;
 	}
@@ -500,9 +499,8 @@ int _mmcamcorder_create_audiosrc_bin(MMHandleType handle)
 	_mmcam_dbg_log("");
 
 	err = _mmcamcorder_check_audiocodec_fileformat_compatibility(handle);
-	if (err != MM_ERROR_NONE) {
+	if (err != MM_ERROR_NONE)
 		return err;
-	}
 
 	err = mm_camcorder_get_attributes(handle, &err_name,
 		MMCAM_AUDIO_DEVICE, &a_dev,
@@ -523,9 +521,9 @@ int _mmcamcorder_create_audiosrc_bin(MMHandleType handle)
 
 	/* Check existence */
 	if (sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst) {
-		if (((GObject *)sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst)->ref_count > 0) {
+		if (((GObject *)sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst)->ref_count > 0)
 			gst_object_unref(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst);
-		}
+
 		_mmcam_dbg_log("_MMCAMCORDER_AUDIOSRC_BIN is Already existed. Unref once...");
 	}
 
@@ -546,9 +544,9 @@ int _mmcamcorder_create_audiosrc_bin(MMHandleType handle)
 	}
 
 	_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-	                              CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT,
-	                              cat_name,
-	                              &AudiosrcElement);
+		CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT,
+		cat_name,
+		&AudiosrcElement);
 	_mmcamcorder_conf_get_value_element_name(AudiosrcElement, &audiosrc_name);
 
 	free(cat_name);
@@ -571,9 +569,8 @@ int _mmcamcorder_create_audiosrc_bin(MMHandleType handle)
 	MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_QUE].gst, "max-size-bytes", 0);
 	MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_QUE].gst, "max-size-time", 0);
 
-	if (a_enc != MM_AUDIO_CODEC_VORBIS) {
+	if (a_enc != MM_AUDIO_CODEC_VORBIS)
 		_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_AUDIOSRC_VOL, "volume", "audiosrc_volume", element_list, err);
-	}
 
 	/* Set basic infomation */
 	if (a_enc != MM_AUDIO_CODEC_VORBIS) {
@@ -597,21 +594,21 @@ int _mmcamcorder_create_audiosrc_bin(MMHandleType handle)
 		}
 
 		caps = gst_caps_new_simple("audio/x-raw",
-					   "rate", G_TYPE_INT, rate,
-					   "channels", G_TYPE_INT, channel,
-					   "format", G_TYPE_STRING, format_name,
-					   NULL);
+			"rate", G_TYPE_INT, rate,
+			"channels", G_TYPE_INT, channel,
+			"format", G_TYPE_STRING, format_name,
+			NULL);
 		_mmcam_dbg_log("caps [x-raw, rate:%d, channel:%d, depth:%d], volume %lf",
-		               rate, channel, depth, volume);
+			rate, channel, depth, volume);
 	} else {
 		/* what are the audio encoder which should get audio/x-raw-float? */
 		caps = gst_caps_new_simple("audio/x-raw",
-					   "rate", G_TYPE_INT, rate,
-					   "channels", G_TYPE_INT, channel,
-					   "format", G_TYPE_STRING, GST_AUDIO_NE(F32),
-					   NULL);
+			"rate", G_TYPE_INT, rate,
+			"channels", G_TYPE_INT, channel,
+			"format", G_TYPE_STRING, GST_AUDIO_NE(F32),
+			NULL);
 		_mmcam_dbg_log("caps [x-raw (F32), rate:%d, channel:%d, endianness:%d, width:32]",
-		               rate, channel, BYTE_ORDER);
+			rate, channel, BYTE_ORDER);
 	}
 
 	if (caps) {
@@ -718,9 +715,9 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 
 	/* Check existence */
 	if (sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst) {
-		if (((GObject *)sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst)->ref_count > 0) {
+		if (((GObject *)sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst)->ref_count > 0)
 			gst_object_unref(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst);
-		}
+
 		_mmcam_dbg_log("_MMCAMCORDER_ENCSINK_BIN is Already existed.");
 	}
 
@@ -778,9 +775,9 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 
 			if (profile == MM_CAMCORDER_ENCBIN_PROFILE_VIDEO) {
 				gst_caps_set_simple(video_caps,
-				                    "width", G_TYPE_INT, sc->info_video->video_width,
-				                    "height", G_TYPE_INT, sc->info_video->video_height,
-				                    NULL);
+					"width", G_TYPE_INT, sc->info_video->video_width,
+					"height", G_TYPE_INT, sc->info_video->video_height,
+					NULL);
 			}
 
 			caps_str = gst_caps_to_string(video_caps);
@@ -799,21 +796,21 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 
 		/* connect signal for ready to push buffer */
 		MMCAMCORDER_SIGNAL_CONNECT(sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst,
-		                           _MMCAMCORDER_HANDLER_VIDEOREC,
-		                           "need-data",
-		                           _mmcamcorder_ready_to_encode_callback,
-		                           hcamcorder);
+			_MMCAMCORDER_HANDLER_VIDEOREC,
+			"need-data",
+			_mmcamcorder_ready_to_encode_callback,
+			hcamcorder);
 	}
 
 	_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_ENCBIN, "encodebin", "encodesink_encbin", element_list, err);
 
 	/* check element availability */
 	err = mm_camcorder_get_attributes(handle, &err_name,
-	                            MMCAM_AUDIO_ENCODER, &audio_enc,
-	                            MMCAM_AUDIO_CHANNEL, &channel,
-	                            MMCAM_VIDEO_ENCODER_BITRATE, &v_bitrate,
-	                            MMCAM_AUDIO_ENCODER_BITRATE, &a_bitrate,
-	                            NULL);
+		MMCAM_AUDIO_ENCODER, &audio_enc,
+		MMCAM_AUDIO_CHANNEL, &channel,
+		MMCAM_VIDEO_ENCODER_BITRATE, &v_bitrate,
+		MMCAM_AUDIO_ENCODER_BITRATE, &a_bitrate,
+		NULL);
 
 	if (err != MM_ERROR_NONE) {
 		if (err_name) {
@@ -852,7 +849,7 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 	_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_RECORD, str_acs, &auto_color_space);
 
 	_mmcam_dbg_log("Profile:%d, AutoAudioConvert:%d, AutoAudioResample:%d, AutoColorSpace:%d",
-	               encodebin_profile, auto_audio_convert, auto_audio_resample, auto_color_space);
+		encodebin_profile, auto_audio_convert, auto_audio_resample, auto_color_space);
 
 	MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "profile", encodebin_profile);
 	MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "auto-audio-convert", auto_audio_convert);
@@ -875,11 +872,10 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 			goto pipeline_creation_error;
 		}
 
-		if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+		if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264)
 			gst_element_venc_name = "capsfilter";
-		} else {
+		else
 			_mmcamcorder_conf_get_value_element_name(VideoencElement, &gst_element_venc_name);
-		}
 
 		if (gst_element_venc_name) {
 			_mmcam_dbg_log("video encoder name [%s]", gst_element_venc_name);
@@ -904,10 +900,8 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 
 			/* fourcc type was removed in GST 1.0 */
 			if (hcamcorder->use_zero_copy_format) {
-				if(strstr(gst_element_venc_name, "omx")) {
-					video_caps = gst_caps_new_simple("video/x-raw",
-							   "format", G_TYPE_STRING, "SN12",
-							   NULL);
+				if (strstr(gst_element_venc_name, "omx")) {
+					video_caps = gst_caps_new_simple("video/x-raw", "format", G_TYPE_STRING, "SN12", NULL);
 
 					if (video_caps) {
 						MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "vcaps", video_caps);
@@ -919,23 +913,22 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 						_mmcam_dbg_warn("failed to create caps");
 					}
 				} else {
-					_mmcam_dbg_log("current video codec is not openmax but [%s]",gst_element_venc_name);
+					_mmcam_dbg_log("current video codec is not openmax but [%s]", gst_element_venc_name);
 				}
 			}
 		}
 
 		_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
-		                                CONFIGURE_CATEGORY_MAIN_RECORD,
-		                                "UseVideoEncoderQueue",
-		                                &use_venc_queue);
-		if (use_venc_queue) {
+			CONFIGURE_CATEGORY_MAIN_RECORD,
+			"UseVideoEncoderQueue",
+			&use_venc_queue);
+		if (use_venc_queue)
 			_MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_VENC_QUE, "use-venc-queue", err);
-		}
 	}
 
 	if (sc->audio_disable == FALSE &&
 	    profile != MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) {
-		int use_aenc_queue =0;
+		int use_aenc_queue = 0;
 
 		AudioencElement = _mmcamcorder_get_type_element(handle, MM_CAM_AUDIO_ENCODER);
 		if (!AudioencElement) {
@@ -951,8 +944,8 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 
 		if (audio_enc == MM_AUDIO_CODEC_AMR && channel == 2) {
 			audio_caps = gst_caps_new_simple("audio/x-raw",
-			                           "channels", G_TYPE_INT, 1,
-			                           NULL);
+											 "channels", G_TYPE_INT, 1,
+											 NULL);
 			MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "auto-audio-convert", TRUE);
 			MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "acaps", audio_caps);
 			gst_caps_unref(audio_caps);
@@ -969,13 +962,13 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 		}
 
 		_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
-		                                CONFIGURE_CATEGORY_MAIN_RECORD,
-		                                "UseAudioEncoderQueue",
-		                                &use_aenc_queue);
+			CONFIGURE_CATEGORY_MAIN_RECORD,
+			"UseAudioEncoderQueue",
+			&use_aenc_queue);
 		if (use_aenc_queue) {
 			_MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_AENC_QUE, "use-aenc-queue", err);
-			MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst,"max-size-time", 0);
-			MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst,"max-size-buffers", 0);
+			MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst, "max-size-time", 0);
+			MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst, "max-size-buffers", 0);
 		}
 	}
 
@@ -1014,9 +1007,9 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 	if (profile != MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) {
 		/* for recording */
 		_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-		                              CONFIGURE_CATEGORY_MAIN_RECORD,
-		                              "RecordsinkElement",
-		                              &RecordsinkElement );
+			CONFIGURE_CATEGORY_MAIN_RECORD,
+			"RecordsinkElement",
+			&RecordsinkElement);
 		_mmcamcorder_conf_get_value_element_name(RecordsinkElement, &gst_element_rsink_name);
 
 		_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_SINK, gst_element_rsink_name, NULL, element_list, err);
@@ -1141,7 +1134,7 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 
 	return MM_ERROR_NONE;
 
-pipeline_creation_error :
+pipeline_creation_error:
 	_mmcamcorder_remove_all_handlers(handle, _MMCAMCORDER_HANDLER_VIDEOREC);
 
 	_MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCSINK_ENCBIN);
@@ -1170,7 +1163,7 @@ int _mmcamcorder_create_preview_pipeline(MMHandleType handle)
 	GstPad *srcpad = NULL;
 	GstBus *bus = NULL;
 
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
 
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
@@ -1187,9 +1180,8 @@ int _mmcamcorder_create_preview_pipeline(MMHandleType handle)
 
 	/* Sub pipeline */
 	err = _mmcamcorder_create_preview_elements((MMHandleType)hcamcorder);
-	if (err != MM_ERROR_NONE) {
+	if (err != MM_ERROR_NONE)
 		goto pipeline_creation_error;
-	}
 
 	/* Set data probe function */
 	if (sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst) {
@@ -1202,7 +1194,8 @@ int _mmcamcorder_create_preview_pipeline(MMHandleType handle)
 
 	if (srcpad) {
 		MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_PREVIEW,
-		                             __mmcamcorder_video_dataprobe_preview, hcamcorder);
+			__mmcamcorder_video_dataprobe_preview, hcamcorder);
+
 		gst_object_unref(srcpad);
 		srcpad = NULL;
 	} else {
@@ -1211,13 +1204,13 @@ int _mmcamcorder_create_preview_pipeline(MMHandleType handle)
 	}
 
 	/* set dataprobe for video recording */
-	if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+	if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264)
 		srcpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "src");
-	} else {
+	else
 		srcpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "src");
-	}
+
 	MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_PREVIEW,
-	                             __mmcamcorder_video_dataprobe_push_buffer_to_record, hcamcorder);
+		__mmcamcorder_video_dataprobe_push_buffer_to_record, hcamcorder);
 	gst_object_unref(srcpad);
 	srcpad = NULL;
 
@@ -1303,19 +1296,19 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi
 
 	/* Get video display information */
 	err = mm_camcorder_get_attributes(handle, &err_name,
-	                                  MMCAM_DISPLAY_RECT_X, &retx,
-	                                  MMCAM_DISPLAY_RECT_Y, &rety,
-	                                  MMCAM_DISPLAY_RECT_WIDTH, &retwidth,
-	                                  MMCAM_DISPLAY_RECT_HEIGHT, &retheight,
-	                                  MMCAM_DISPLAY_ROTATION, &rotation,
-	                                  MMCAM_DISPLAY_FLIP, &flip,
-	                                  MMCAM_DISPLAY_VISIBLE, &visible,
-	                                  MMCAM_DISPLAY_HANDLE, (void**)&overlay, &size,
-	                                  MMCAM_DISPLAY_MODE, &display_mode,
-	                                  MMCAM_DISPLAY_GEOMETRY_METHOD, &display_geometry_method,
-	                                  MMCAM_DISPLAY_SCALE, &zoom_attr,
-	                                  MMCAM_DISPLAY_EVAS_DO_SCALING, &do_scaling,
-	                                  NULL);
+		MMCAM_DISPLAY_RECT_X, &retx,
+		MMCAM_DISPLAY_RECT_Y, &rety,
+		MMCAM_DISPLAY_RECT_WIDTH, &retwidth,
+		MMCAM_DISPLAY_RECT_HEIGHT, &retheight,
+		MMCAM_DISPLAY_ROTATION, &rotation,
+		MMCAM_DISPLAY_FLIP, &flip,
+		MMCAM_DISPLAY_VISIBLE, &visible,
+		MMCAM_DISPLAY_HANDLE, (void**)&overlay, &size,
+		MMCAM_DISPLAY_MODE, &display_mode,
+		MMCAM_DISPLAY_GEOMETRY_METHOD, &display_geometry_method,
+		MMCAM_DISPLAY_SCALE, &zoom_attr,
+		MMCAM_DISPLAY_EVAS_DO_SCALING, &do_scaling,
+		NULL);
 	if (err != MM_ERROR_NONE) {
 		if (err_name) {
 			_mmcam_dbg_err("failed to get attributes [%s][0x%x]", err_name, err);
@@ -1348,9 +1341,9 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi
 
 		MMCAMCORDER_G_OBJECT_SET(vsink, "device-scaler", display_scaler);
 #endif /* _MMCAMCORDER_RM_SUPPORT */
-	} else if (!strcmp(videosink_name, "evasimagesink") ||
-	           !strcmp(videosink_name, "evaspixmapsink")) {
+	} else if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink")) {
 		_mmcam_dbg_log("videosink : %s, handle : %p", videosink_name, overlay);
+
 		if (overlay) {
 			MMCAMCORDER_G_OBJECT_SET_POINTER(vsink, "evas-object", overlay);
 			MMCAMCORDER_G_OBJECT_SET(vsink, "origin-size", !do_scaling);
@@ -1360,6 +1353,7 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi
 		}
 	} else if (!strcmp(videosink_name, "waylandsink")) {
 		MMCamWaylandInfo *wl_info = (MMCamWaylandInfo *)overlay;
+
 		if (wl_info) {
 			_mmcam_dbg_log("wayland global surface id : %d", wl_info->global_surface_id);
 			gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(vsink), (guintptr)wl_info->global_surface_id);
@@ -1379,7 +1373,7 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi
 	}
 
 	_mmcam_dbg_log("%s set: display_geometry_method[%d],origin-size[%d],visible[%d],rotate[%d],flip[%d]",
-	               videosink_name, display_geometry_method, origin_size, visible, rotation, flip);
+		videosink_name, display_geometry_method, origin_size, visible, rotation, flip);
 
 	/* Set attribute */
 	if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink") ||
@@ -1413,11 +1407,11 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi
 
 		if (display_geometry_method == MM_DISPLAY_METHOD_CUSTOM_ROI) {
 			g_object_set(vsink,
-			             "dst-roi-x", retx,
-			             "dst-roi-y", rety,
-			             "dst-roi-w", retwidth,
-			             "dst-roi-h", retheight,
-			             NULL);
+				"dst-roi-x", retx,
+				"dst-roi-y", rety,
+				"dst-roi-w", retwidth,
+				"dst-roi-h", retheight,
+				NULL);
 		}
 	}
 
@@ -1427,7 +1421,7 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi
 
 int _mmcamcorder_vframe_stablize(MMHandleType handle)
 {
-	mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
 
 	_mmcam_dbg_log("%d", _MMCAMCORDER_CAMSTABLE_COUNT);
@@ -1438,9 +1432,8 @@ int _mmcamcorder_vframe_stablize(MMHandleType handle)
 
 	mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
-	if (sc->cam_stability_count != _MMCAMCORDER_CAMSTABLE_COUNT) {
+	if (sc->cam_stability_count != _MMCAMCORDER_CAMSTABLE_COUNT)
 		sc->cam_stability_count = _MMCAMCORDER_CAMSTABLE_COUNT;
-	}
 
 	return MM_ERROR_NONE;
 }
@@ -1468,7 +1461,7 @@ gboolean _mmcamcorder_get_device_info(MMHandleType handle)
 			/* Exif related information */
 			control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
 			if (control != NULL) {
-				gst_camera_control_get_exif_info(control, &exif_info); //get video input device information
+				gst_camera_control_get_exif_info(control, &exif_info); /* get video input device information */
 				if (exif_info.focal_len_denominator != 0)
 					focal_len = ((double)exif_info.focal_len_numerator) / ((double) exif_info.focal_len_denominator);
 			} else {
@@ -1479,15 +1472,15 @@ gboolean _mmcamcorder_get_device_info(MMHandleType handle)
 
 		/* Set values to attributes */
 		err = mm_camcorder_set_attributes(handle, &err_name,
-		                                  MMCAM_CAMERA_FOCAL_LENGTH, focal_len,
-		                                  NULL);
+			MMCAM_CAMERA_FOCAL_LENGTH, focal_len,
+			NULL);
 		if (err != MM_ERROR_NONE) {
 			_mmcam_dbg_err("Set attributes error(%s:%x)!", err_name, err);
 			SAFE_FREE(err_name);
 			return FALSE;
 		}
 	} else {
-		_mmcam_dbg_warn( "Sub context isn't exist.");
+		_mmcam_dbg_warn("Sub context isn't exist.");
 		return FALSE;
 	}
 
@@ -1496,7 +1489,7 @@ gboolean _mmcamcorder_get_device_info(MMHandleType handle)
 
 static guint32 _mmcamcorder_convert_fourcc_string_to_value(const gchar* format_name)
 {
-    return format_name[0] | (format_name[1] << 8) | (format_name[2] << 16) | (format_name[3] << 24);
+	return format_name[0] | (format_name[1] << 8) | (format_name[2] << 16) | (format_name[3] << 24);
 }
 
 static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
@@ -1592,16 +1585,17 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
 
 		caps = gst_pad_get_current_caps(pad);
 		if (caps == NULL) {
-			_mmcam_dbg_warn( "Caps is NULL." );
+			_mmcam_dbg_warn("Caps is NULL.");
 			return GST_PAD_PROBE_OK;
 		}
 
 		/* clear stream data structure */
 		memset(&stream, 0x0, sizeof(MMCamcorderVideoStreamDataType));
 
-		structure = gst_caps_get_structure( caps, 0 );
+		structure = gst_caps_get_structure(caps, 0);
 		gst_structure_get_int(structure, "width", &(stream.width));
 		gst_structure_get_int(structure, "height", &(stream.height));
+
 		if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
 			stream.format = MM_PIXEL_FORMAT_ENCODED_H264;
 		} else {
@@ -1612,15 +1606,17 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
 				_mmcam_dbg_warn("get string error!!");
 				return GST_PAD_PROBE_OK;
 			}
+
 			fourcc = _mmcamcorder_convert_fourcc_string_to_value(string_format);
 			stream.format = _mmcamcorder_get_pixtype(fourcc);
 		}
+
 		gst_caps_unref(caps);
 		caps = NULL;
 
 		/*
-		_mmcam_dbg_log( "Call video steramCb, data[%p], Width[%d],Height[%d], Format[%d]",
-		                GST_BUFFER_DATA(buffer), stream.width, stream.height, stream.format );
+		_mmcam_dbg_log("Call video steramCb, data[%p], Width[%d],Height[%d], Format[%d]",
+			GST_BUFFER_DATA(buffer), stream.width, stream.height, stream.format);
 		*/
 
 		if (stream.width == 0 || stream.height == 0) {
@@ -1654,9 +1650,9 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
 					stream.data.yuv420sp.length_uv = stream.data.yuv420sp.length_y >> 1;
 					/*
 					_mmcam_dbg_log("format[%d][num_planes:%d] [Y]p:0x%x,size:%d [UV]p:0x%x,size:%d",
-					               stream.format, stream.num_planes,
-					               stream.data.yuv420sp.y, stream.data.yuv420sp.length_y,
-					               stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv);
+						stream.format, stream.num_planes,
+						stream.data.yuv420sp.y, stream.data.yuv420sp.length_y,
+						stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv);
 					*/
 				} else {
 					stream.data_type = MM_CAM_STREAM_DATA_YUV420P;
@@ -1669,10 +1665,10 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
 					stream.data.yuv420p.length_v = stream.data.yuv420p.length_u;
 					/*
 					_mmcam_dbg_log("S420[num_planes:%d] [Y]p:0x%x,size:%d [U]p:0x%x,size:%d [V]p:0x%x,size:%d",
-					                stream.num_planes,
-					                stream.data.yuv420p.y, stream.data.yuv420p.length_y,
-					                stream.data.yuv420p.u, stream.data.yuv420p.length_u,
-					                stream.data.yuv420p.v, stream.data.yuv420p.length_v);
+						stream.num_planes,
+						stream.data.yuv420p.y, stream.data.yuv420p.length_y,
+						stream.data.yuv420p.u, stream.data.yuv420p.length_u,
+						stream.data.yuv420p.v, stream.data.yuv420p.length_v);
 					*/
 				}
 			} else {
@@ -1691,9 +1687,9 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
 					stream.elevation[1] = stream.height >> 1;
 					/*
 					_mmcam_dbg_log("format[%d][num_planes:%d] [Y]p:0x%x,size:%d [UV]p:0x%x,size:%d",
-					               stream.format, stream.num_planes,
-					               stream.data.yuv420sp.y, stream.data.yuv420sp.length_y,
-					               stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv);
+						stream.format, stream.num_planes,
+						stream.data.yuv420sp.y, stream.data.yuv420sp.length_y,
+						stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv);
 					*/
 				} else {
 					stream.data_type = MM_CAM_STREAM_DATA_YUV420P;
@@ -1712,10 +1708,10 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
 					stream.elevation[2] = stream.height >> 1;
 					/*
 					_mmcam_dbg_log("I420[num_planes:%d] [Y]p:0x%x,size:%d [U]p:0x%x,size:%d [V]p:0x%x,size:%d",
-					                stream.num_planes,
-					                stream.data.yuv420p.y, stream.data.yuv420p.length_y,
-					                stream.data.yuv420p.u, stream.data.yuv420p.length_u,
-					                stream.data.yuv420p.v, stream.data.yuv420p.length_v);
+						stream.num_planes,
+						stream.data.yuv420p.y, stream.data.yuv420p.length_y,
+						stream.data.yuv420p.u, stream.data.yuv420p.length_u,
+						stream.data.yuv420p.v, stream.data.yuv420p.length_v);
 					*/
 				}
 			}
@@ -1752,8 +1748,8 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
 			stream.num_planes = 1;
 			/*
 			_mmcam_dbg_log("%c%c%c%c[num_planes:%d] [0]p:0x%x,size:%d",
-			               fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
-			               stream.num_planes, stream.data.yuv420.yuv, stream.data.yuv420.length_yuv);
+				fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
+				stream.num_planes, stream.data.yuv420.yuv, stream.data.yuv420.length_yuv);
 			*/
 		}
 
@@ -1780,13 +1776,13 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
 				tbm_bo_unmap(stream.bo[i]);
 			}
 		}
+
 		_MMCAMCORDER_UNLOCK_VSTREAM_CALLBACK(hcamcorder);
 		/* Either metaBlock was mapped, or dataBlock, but not both. */
-		if (metaBlock) {
+		if (metaBlock)
 			gst_memory_unmap(metaBlock, &mapinfo);
-		}else {
+		else
 			gst_memory_unmap(dataBlock, &mapinfo);
-		}
 	}
 
 	return GST_PAD_PROBE_OK;
@@ -1807,7 +1803,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_push_buffer_to_record(Gst
 	mmf_return_val_if_fail(sc, GST_PAD_PROBE_DROP);
 
 	/* push buffer in appsrc to encode */
-	if(!sc->info_video) {
+	if (!sc->info_video) {
 		_mmcam_dbg_warn("sc->info_video is NULL!!");
 		return FALSE;
 	}
@@ -1820,7 +1816,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_push_buffer_to_record(Gst
 
 		/*
 		_mmcam_dbg_log("GST_BUFFER_FLAG_DELTA_UNIT is set : %d",
-		               GST_BUFFER_FLAG_IS_SET(buffer, GST_BUFFER_FLAG_DELTA_UNIT));
+			GST_BUFFER_FLAG_IS_SET(buffer, GST_BUFFER_FLAG_DELTA_UNIT));
 		*/
 
 		/* check first I frame */
@@ -1846,7 +1842,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_push_buffer_to_record(Gst
 				}
 			}
 		} else {
-			if(sc->info_video->is_firstframe) {
+			if (sc->info_video->is_firstframe) {
 				/* for image capture with encodebin(ex:emulator) */
 				if (sc->bencbin_capture && sc->info_image->capturing) {
 					g_mutex_lock(&hcamcorder->task_thread_lock);
@@ -1908,15 +1904,15 @@ int __mmcamcorder_get_amrnb_bitrate_mode(int bitrate)
 {
 	int result = MM_CAMCORDER_MR475;
 
-	if (bitrate< 5150) {
+	if (bitrate < 5150) {
 		result = MM_CAMCORDER_MR475; /*AMR475*/
-	} else if (bitrate< 5900) {
+	} else if (bitrate < 5900) {
 		result = MM_CAMCORDER_MR515; /*AMR515*/
 	} else if (bitrate < 6700) {
 		result = MM_CAMCORDER_MR59; /*AMR59*/
-	} else if (bitrate< 7400) {
+	} else if (bitrate < 7400) {
 		result = MM_CAMCORDER_MR67; /*AMR67*/
-	} else if (bitrate< 7950) {
+	} else if (bitrate < 7950) {
 		result = MM_CAMCORDER_MR74; /*AMR74*/
 	} else if (bitrate < 10200) {
 		result = MM_CAMCORDER_MR795; /*AMR795*/
@@ -1962,14 +1958,12 @@ int _mmcamcorder_get_eos_message(MMHandleType handle)
 	if (hcamcorder->error_code == MM_ERROR_NONE) {
 		if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
 			mmf_return_val_if_fail(sc->info_video, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
-			if (sc->info_video->b_commiting) {
+			if (sc->info_video->b_commiting)
 				_mmcamcorder_video_handle_eos((MMHandleType)hcamcorder);
-			}
 		} else {
 			mmf_return_val_if_fail(sc->info_audio, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
-			if (sc->info_audio->b_commiting) {
+			if (sc->info_audio->b_commiting)
 				_mmcamcorder_audio_handle_eos((MMHandleType)hcamcorder);
-			}
 		}
 	} else {
 		ret = hcamcorder->error_code;
@@ -2010,9 +2004,9 @@ int _mmcamcorder_check_audiocodec_fileformat_compatibility(MMHandleType handle)
 	char *err_name = NULL;
 
 	err = mm_camcorder_get_attributes(handle, &err_name,
-	                                  MMCAM_AUDIO_ENCODER, &audio_codec,
-	                                  MMCAM_FILE_FORMAT, &file_format,
-	                                  NULL);
+									  MMCAM_AUDIO_ENCODER, &audio_codec,
+									  MMCAM_FILE_FORMAT, &file_format,
+									  NULL);
 	if (err != MM_ERROR_NONE) {
 		_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
 		SAFE_FREE(err_name);
@@ -2024,15 +2018,15 @@ int _mmcamcorder_check_audiocodec_fileformat_compatibility(MMHandleType handle)
 	    file_format > MM_FILE_FORMAT_INVALID && file_format < MM_FILE_FORMAT_NUM) {
 		if (audiocodec_fileformat_compatibility_table[audio_codec][file_format] == 0) {
 			_mmcam_dbg_err("Audio codec[%d] and file format[%d] compatibility FAILED.",
-			               audio_codec, file_format);
+				audio_codec, file_format);
 			return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE;
 		}
 
 		_mmcam_dbg_log("Audio codec[%d] and file format[%d] compatibility SUCCESS.",
-		               audio_codec, file_format);
+			audio_codec, file_format);
 	} else {
 		_mmcam_dbg_err("Audio codec[%d] or file format[%d] is INVALID.",
-		               audio_codec, file_format);
+			audio_codec, file_format);
 		return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE;
 	}
 
@@ -2049,9 +2043,9 @@ int _mmcamcorder_check_videocodec_fileformat_compatibility(MMHandleType handle)
 	char *err_name = NULL;
 
 	err = mm_camcorder_get_attributes(handle, &err_name,
-	                                  MMCAM_VIDEO_ENCODER, &video_codec,
-	                                  MMCAM_FILE_FORMAT, &file_format,
-	                                  NULL);
+		MMCAM_VIDEO_ENCODER, &video_codec,
+		MMCAM_FILE_FORMAT, &file_format,
+		NULL);
 	if (err != MM_ERROR_NONE) {
 		_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
 		SAFE_FREE(err_name);
@@ -2063,15 +2057,15 @@ int _mmcamcorder_check_videocodec_fileformat_compatibility(MMHandleType handle)
 	    file_format > MM_FILE_FORMAT_INVALID && file_format < MM_FILE_FORMAT_NUM) {
 		if (videocodec_fileformat_compatibility_table[video_codec][file_format] == 0) {
 			_mmcam_dbg_err("Video codec[%d] and file format[%d] compatibility FAILED.",
-			               video_codec, file_format);
+				video_codec, file_format);
 			return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE;
 		}
 
 		_mmcam_dbg_log("Video codec[%d] and file format[%d] compatibility SUCCESS.",
-		               video_codec, file_format);
+			video_codec, file_format);
 	} else {
 		_mmcam_dbg_err("Video codec[%d] or file format[%d] is INVALID.",
-		               video_codec, file_format);
+			video_codec, file_format);
 		return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE;
 	}
 
@@ -2174,10 +2168,10 @@ bool _mmcamcorder_set_videosrc_rotation(MMHandleType handle, int videosrc_rotate
 	}
 
 	mm_camcorder_get_attributes(handle, NULL,
-	                            MMCAM_CAMERA_WIDTH, &width,
-	                            MMCAM_CAMERA_HEIGHT, &height,
-	                            MMCAM_CAMERA_FPS, &fps,
-	                            NULL);
+		MMCAM_CAMERA_WIDTH, &width,
+		MMCAM_CAMERA_HEIGHT, &height,
+		MMCAM_CAMERA_FPS, &fps,
+		NULL);
 
 	_mmcam_dbg_log("set rotate %d", videosrc_rotate);
 
@@ -2232,18 +2226,18 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
 		double motion_rate = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
 
 		mm_camcorder_get_attributes(handle, NULL,
-		                            MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
-		                            MMCAM_CAMERA_FPS_AUTO, &fps_auto,
-		                            MMCAM_CAPTURE_WIDTH, &capture_width,
-		                            MMCAM_CAPTURE_HEIGHT, &capture_height,
-		                            MMCAM_VIDEO_WIDTH, &sc->info_video->video_width,
-		                            MMCAM_VIDEO_HEIGHT, &sc->info_video->video_height,
-		                            NULL);
+			MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
+			MMCAM_CAMERA_FPS_AUTO, &fps_auto,
+			MMCAM_CAPTURE_WIDTH, &capture_width,
+			MMCAM_CAPTURE_HEIGHT, &capture_height,
+			MMCAM_VIDEO_WIDTH, &sc->info_video->video_width,
+			MMCAM_VIDEO_HEIGHT, &sc->info_video->video_height,
+			NULL);
 		_mmcam_dbg_log("motion rate %f, capture size %dx%d, fps auto %d, video size %dx%d",
-		               motion_rate, capture_width, capture_height, fps_auto,
-		               sc->info_video->video_width, sc->info_video->video_height);
+			motion_rate, capture_width, capture_height, fps_auto,
+			sc->info_video->video_width, sc->info_video->video_height);
 
-		if(motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
+		if (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
 			MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", fps);
 		} else {
 			MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", 0);
@@ -2273,11 +2267,10 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
 			set_width = height;
 			set_height = width;
 			if (hcamcorder->device_type == MM_VIDEO_DEVICE_CAMERA1) {
-				if (rotate == MM_VIDEO_INPUT_ROTATION_90) {
+				if (rotate == MM_VIDEO_INPUT_ROTATION_90)
 					set_rotate = 270;
-				} else {
+				else
 					set_rotate = 90;
-				}
 			}
 		} else {
 			set_width = width;
@@ -2305,9 +2298,9 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
 			int caps_rotate = 0;
 
 			format_string = gst_structure_get_string(structure, "format");
-			if (format_string) {
+			if (format_string)
 				caps_fourcc = _mmcamcorder_convert_fourcc_string_to_value(format_string);
-			}
+
 			gst_structure_get_int(structure, "width", &caps_width);
 			gst_structure_get_int(structure, "height", &caps_height);
 			gst_structure_get_int(structure, "fps", &caps_fps);
@@ -2319,10 +2312,10 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
 					_mmcam_dbg_log("No need to replace caps.");
 				} else {
 					_mmcam_dbg_log("current [%c%c%c%c %dx%d, fps %d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
-					               caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
-					               caps_width, caps_height, caps_fps, caps_rotate,
-					               fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
-					               set_width, set_height, fps, set_rotate);
+						caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
+						caps_width, caps_height, caps_fps, caps_rotate,
+						fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
+						set_width, set_height, fps, set_rotate);
 					do_set_caps = TRUE;
 				}
 			} else {
@@ -2331,10 +2324,10 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
 					_mmcam_dbg_log("No need to replace caps.");
 				} else {
 					_mmcam_dbg_log("current [%c%c%c%c %dx%d, fps %d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
-					               caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
-					               caps_width, caps_height, caps_fps, caps_rotate,
-					               fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
-					               set_width, set_height, fps, set_rotate);
+						caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
+						caps_width, caps_height, caps_fps, caps_rotate,
+						fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
+						set_width, set_height, fps, set_rotate);
 					do_set_caps = TRUE;
 				}
 			}
@@ -2344,10 +2337,10 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
 				_mmcam_dbg_log("No need to replace caps.");
 			} else {
 				_mmcam_dbg_log("current [%c%c%c%c %dx%d, fps %d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
-				               caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
-				               caps_width, caps_height, caps_fps, caps_rotate,
-				               fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
-				               set_width, set_height, fps, set_rotate);
+					caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
+					caps_width, caps_height, caps_fps, caps_rotate,
+					fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
+					set_width, set_height, fps, set_rotate);
 				do_set_caps = TRUE;
 			}
 #endif /*_MMCAMCORDER_PRODUCT_TV */
@@ -2381,7 +2374,7 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
 				return FALSE;
 			}
 
-			decsink_struct = gst_caps_get_structure(decsink_caps,0);
+			decsink_struct = gst_caps_get_structure(decsink_caps, 0);
 			if (!decsink_struct) {
 				_mmcam_dbg_err("There are no structure from caps");
 				gst_object_unref(decsink_caps);
@@ -2389,24 +2382,24 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
 				return FALSE;
 			}
 
-			if(gst_structure_has_field(decsink_struct, "maxwidth")){
+			if (gst_structure_has_field(decsink_struct, "maxwidth"))
 				gst_structure_get_int(decsink_struct, "maxwidth", &maxwidth);
-			}
-			if(gst_structure_has_field(decsink_struct, "maxheight")){
+
+			if (gst_structure_has_field(decsink_struct, "maxheight"))
 				gst_structure_get_int(decsink_struct, "maxheight", &maxheight);
-			}
 #endif /* _MMCAMCORDER_PRODUCT_TV */
+
 			caps = gst_caps_new_simple("video/x-h264",
-					"width", G_TYPE_INT, set_width,
-					"height", G_TYPE_INT, set_height,
-					"framerate", GST_TYPE_FRACTION, fps, 1,
-					"stream-format", G_TYPE_STRING, "byte-stream",
+				"width", G_TYPE_INT, set_width,
+				"height", G_TYPE_INT, set_height,
+				"framerate", GST_TYPE_FRACTION, fps, 1,
+				"stream-format", G_TYPE_STRING, "byte-stream",
 #ifdef _MMCAMCORDER_PRODUCT_TV
-					"maxwidth", G_TYPE_INT, maxwidth,
-					"maxheight", G_TYPE_INT, maxheight,
-					"alignment", G_TYPE_STRING, "au",
+				"maxwidth", G_TYPE_INT, maxwidth,
+				"maxheight", G_TYPE_INT, maxheight,
+				"alignment", G_TYPE_STRING, "au",
 #endif /* _MMCAMCORDER_PRODUCT_TV */
-					NULL);
+				NULL);
 
 #ifdef _MMCAMCORDER_PRODUCT_TV
 			gst_object_unref(decsink_caps);
@@ -2417,12 +2410,12 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
 			strncpy(fourcc_string, (char*)&fourcc, sizeof(fourcc));
 			fourcc_string[sizeof(fourcc)] = '\0';
 			caps = gst_caps_new_simple("video/x-raw",
-					"format", G_TYPE_STRING, fourcc_string,
-					"width", G_TYPE_INT, set_width,
-					"height", G_TYPE_INT, set_height,
-					"framerate", GST_TYPE_FRACTION, fps, 1,
-					"rotate", G_TYPE_INT, set_rotate,
-					NULL);
+				"format", G_TYPE_STRING, fourcc_string,
+				"width", G_TYPE_INT, set_width,
+				"height", G_TYPE_INT, set_height,
+				"framerate", GST_TYPE_FRACTION, fps, 1,
+				"rotate", G_TYPE_INT, set_rotate,
+				NULL);
 		}
 
 		if (caps) {
@@ -2452,9 +2445,8 @@ bool _mmcamcorder_set_videosrc_flip(MMHandleType handle, int videosrc_flip)
 	mmf_return_val_if_fail(hcamcorder, FALSE);
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	_mmcam_dbg_log("Set FLIP %d", videosrc_flip);
 
@@ -2473,7 +2465,7 @@ bool _mmcamcorder_set_videosrc_flip(MMHandleType handle, int videosrc_flip)
 			MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "vflip", vflip);
 		} else {
 			_mmcam_dbg_warn("ITLV format does not support FLIP. Ignore FLIP[%d]",
-			                videosrc_flip);
+				videosrc_flip);
 		}
 	} else {
 		_mmcam_dbg_warn("element is NULL");
@@ -2495,9 +2487,8 @@ bool _mmcamcorder_set_videosrc_anti_shake(MMHandleType handle, int anti_shake)
 	mmf_return_val_if_fail(handle, FALSE);
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	v_src = sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst;
 
@@ -2534,9 +2525,8 @@ bool _mmcamcorder_set_videosrc_stabilization(MMHandleType handle, int stabilizat
 	mmf_return_val_if_fail(handle, FALSE);
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	v_src = sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst;
 	if (!v_src) {
@@ -2545,7 +2535,7 @@ bool _mmcamcorder_set_videosrc_stabilization(MMHandleType handle, int stabilizat
 	}
 
 	/* check property of videosrc element - support VDIS */
-	if(g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(v_src)), "enable-vdis-mode")) {
+	if (g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(v_src)), "enable-vdis-mode")) {
 		int video_width = 0;
 		int video_height = 0;
 
@@ -2554,28 +2544,28 @@ bool _mmcamcorder_set_videosrc_stabilization(MMHandleType handle, int stabilizat
 
 			/* VDIS mode only supports NV12 and [720p or 1080p or 1088 * 1088] */
 			mm_camcorder_get_attributes(handle, NULL,
-			                            MMCAM_VIDEO_WIDTH, &video_width,
-			                            MMCAM_VIDEO_HEIGHT, &video_height,
-			                            NULL);
-			if (sc->info_image->preview_format == MM_PIXEL_FORMAT_NV12 &&
-			    video_width >= 1080 && video_height >= 720) {
+				MMCAM_VIDEO_WIDTH, &video_width,
+				MMCAM_VIDEO_HEIGHT, &video_height,
+				NULL);
+
+			if (sc->info_image->preview_format == MM_PIXEL_FORMAT_NV12 && video_width >= 1080 && video_height >= 720) {
 				_mmcam_dbg_log("NV12, video size %dx%d, ENABLE video stabilization",
-				               video_width, video_height, stabilization);
+					video_width, video_height, stabilization);
 				/* set vdis mode */
 				g_object_set(G_OBJECT(v_src),
-				             "enable-vdis-mode", TRUE,
-				             NULL);
+							 "enable-vdis-mode", TRUE,
+							 NULL);
 			} else {
 				_mmcam_dbg_warn("invalid preview format %c%c%c%c or video size %dx%d",
-				                sc->fourcc, sc->fourcc>>8, sc->fourcc>>16, sc->fourcc>>24,
-				                video_width, video_height);
+								sc->fourcc, sc->fourcc>>8, sc->fourcc>>16, sc->fourcc>>24,
+								video_width, video_height);
 				return FALSE;
 			}
 		} else {
 			/* set vdis mode */
 			g_object_set(G_OBJECT(v_src),
-			             "enable-vdis-mode", FALSE,
-			             NULL);
+						"enable-vdis-mode", FALSE,
+						NULL);
 
 			_mmcam_dbg_log("DISABLE video stabilization");
 		}
@@ -2600,13 +2590,12 @@ bool _mmcamcorder_set_camera_resolution(MMHandleType handle, int width, int heig
 	mmf_return_val_if_fail(hcamcorder, FALSE);
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-	if (!sc) {
+	if (!sc)
 		return TRUE;
-	}
 
 	mm_camcorder_get_attributes(handle, NULL,
-	                            MMCAM_CAMERA_FPS, &fps,
-	                            NULL);
+		MMCAM_CAMERA_FPS, &fps,
+		NULL);
 
 	_mmcam_dbg_log("set %dx%d", width, height);
 
diff --git a/src/mm_camcorder_internal.c b/src/mm_camcorder_internal.c
index e99298e..076f2ac 100644
--- a/src/mm_camcorder_internal.c
+++ b/src/mm_camcorder_internal.c
@@ -84,7 +84,7 @@ static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage
 
 #ifdef _MMCAMCORDER_RM_SUPPORT
 rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
-        rm_device_request_s *info, void *cb_data);
+									  rm_device_request_s *info, void *cb_data);
 #endif /* _MMCAMCORDER_RM_SUPPORT */
 #ifdef _MMCAMCORDER_USE_SET_ATTR_CB
 static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data);
@@ -196,18 +196,16 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 			goto _ERR_DEFAULT_VALUE_INIT;
 		}
 
-		if (MM_ERROR_NONE != mm_sound_register_focus_for_session(hcamcorder->sound_focus_id,
-		                                                         getpid(),
-		                                                         "media",
-		                                                         _mmcamcorder_sound_focus_cb,
-		                                                         hcamcorder)) {
+		ret = mm_sound_register_focus_for_session(hcamcorder->sound_focus_id,
+			getpid(), "media", _mmcamcorder_sound_focus_cb, hcamcorder);
+		if (ret != MM_ERROR_NONE) {
 			_mmcam_dbg_err("mm_sound_register_focus failed");
 			ret = MM_ERROR_POLICY_BLOCKED;
 			goto _ERR_DEFAULT_VALUE_INIT;
 		}
 
 		_mmcam_dbg_log("mm_sound_register_focus done - id %d, session type %d, flags 0x%x",
-			       hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags);
+			hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags);
 	} else {
 		_mmcam_dbg_log("_mm_session_util_read_information failed. skip sound focus function.");
 		hcamcorder->sound_focus_register = FALSE;
@@ -243,29 +241,29 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 
 	if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
 		_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
-		                                CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
-		                                "UseConfCtrl", &UseConfCtrl);
+			CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+			"UseConfCtrl", &UseConfCtrl);
 
 		if (UseConfCtrl) {
 			int resolution_width = 0;
 			int resolution_height = 0;
 			MMCamAttrsInfo fps_info;
 
-			_mmcam_dbg_log( "Enable Configure Control system." );
+			_mmcam_dbg_log("Enable Configure Control system.");
 
 			switch (info->videodev_type) {
 			case MM_VIDEO_DEVICE_CAMERA0:
 				_mmcamcorder_conf_get_value_string((MMHandleType)hcamcorder, hcamcorder->conf_main,
-				                                   CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
-				                                   "ConfCtrlFile0", &ConfCtrlFile);
+					CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+					"ConfCtrlFile0", &ConfCtrlFile);
 				break;
 			case MM_VIDEO_DEVICE_CAMERA1:
 				_mmcamcorder_conf_get_value_string((MMHandleType)hcamcorder, hcamcorder->conf_main,
-				                                   CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
-				                                   "ConfCtrlFile1", &ConfCtrlFile);
+					CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+					"ConfCtrlFile1", &ConfCtrlFile);
 				break;
 			default:
-				_mmcam_dbg_err( "Not supported camera type." );
+				_mmcam_dbg_err("Not supported camera type.");
 				ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
 				goto _ERR_DEFAULT_VALUE_INIT;
 			}
@@ -297,72 +295,72 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 
 			/* Get device info, recommend preview fmt and display rotation from INI */
 			_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
-			                                CONFIGURE_CATEGORY_CTRL_CAMERA,
-			                                "RecommendPreviewFormatCapture",
-			                                &rcmd_fmt_capture);
+				CONFIGURE_CATEGORY_CTRL_CAMERA,
+				"RecommendPreviewFormatCapture",
+				&rcmd_fmt_capture);
 
 			_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
-			                                CONFIGURE_CATEGORY_CTRL_CAMERA,
-			                                "RecommendPreviewFormatRecord",
-			                                &rcmd_fmt_recording);
+				CONFIGURE_CATEGORY_CTRL_CAMERA,
+				"RecommendPreviewFormatRecord",
+				&rcmd_fmt_recording);
 
 			_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
-			                                CONFIGURE_CATEGORY_CTRL_CAMERA,
-			                                "RecommendDisplayRotation",
-			                                &rcmd_dpy_rotation);
+				CONFIGURE_CATEGORY_CTRL_CAMERA,
+				"RecommendDisplayRotation",
+				&rcmd_dpy_rotation);
 
 			_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
-			                                CONFIGURE_CATEGORY_MAIN_CAPTURE,
-			                                "PlayCaptureSound",
-			                                &play_capture_sound);
+				CONFIGURE_CATEGORY_MAIN_CAPTURE,
+				"PlayCaptureSound",
+				&play_capture_sound);
 
 			_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
-			                                CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
-			                                "DeviceCount",
-			                                &camera_device_count);
+				CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+				"DeviceCount",
+				&camera_device_count);
 
 			_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
-			                                CONFIGURE_CATEGORY_CTRL_CAMERA,
-			                                "FacingDirection",
-			                                &camera_facing_direction);
+				CONFIGURE_CATEGORY_CTRL_CAMERA,
+				"FacingDirection",
+				&camera_facing_direction);
 
 			_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
-			                                CONFIGURE_CATEGORY_CTRL_EFFECT,
-			                                "BrightnessStepDenominator",
-			                                &hcamcorder->brightness_step_denominator);
+				CONFIGURE_CATEGORY_CTRL_EFFECT,
+				"BrightnessStepDenominator",
+				&hcamcorder->brightness_step_denominator);
 
 			_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
-			                                CONFIGURE_CATEGORY_CTRL_CAPTURE,
-			                                "SupportZSL",
-			                                &hcamcorder->support_zsl_capture);
+				CONFIGURE_CATEGORY_CTRL_CAPTURE,
+				"SupportZSL",
+				&hcamcorder->support_zsl_capture);
 
 			_mmcam_dbg_log("Recommend fmt[cap:%d,rec:%d], dpy rot %d, cap snd %d, dev cnt %d, cam facing dir %d, step denom %d, support zsl %d",
-			               rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation,
-			               play_capture_sound, camera_device_count, camera_facing_direction,
-			               hcamcorder->brightness_step_denominator, hcamcorder->support_zsl_capture);
+				rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation,
+				play_capture_sound, camera_device_count, camera_facing_direction,
+				hcamcorder->brightness_step_denominator, hcamcorder->support_zsl_capture);
 
 			/* Get UseZeroCopyFormat value from INI */
 			_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
-			                                CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
-			                                "UseZeroCopyFormat",
-			                                &(hcamcorder->use_zero_copy_format));
+				CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+				"UseZeroCopyFormat",
+				&(hcamcorder->use_zero_copy_format));
 
 			/* Get SupportMediaPacketPreviewCb value from INI */
 			_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
-			                                CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
-			                                "SupportMediaPacketPreviewCb",
-			                                &(hcamcorder->support_media_packet_preview_cb));
+				CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+				"SupportMediaPacketPreviewCb",
+				&(hcamcorder->support_media_packet_preview_cb));
 
 			/* Get UseVideoconvert value from INI */
 			_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
-			                                CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
-			                                "UseVideoconvert",
-			                                &hcamcorder->use_videoconvert);
+				CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+				"UseVideoconvert",
+				&hcamcorder->use_videoconvert);
 
 			ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
-			                            MMCAM_CAMERA_WIDTH, &resolution_width,
-			                            MMCAM_CAMERA_HEIGHT, &resolution_height,
-			                            NULL);
+				MMCAM_CAMERA_WIDTH, &resolution_width,
+				MMCAM_CAMERA_HEIGHT, &resolution_height,
+				NULL);
 
 			mm_camcorder_get_fps_list_by_resolution((MMHandleType)hcamcorder, resolution_width, resolution_height, &fps_info);
 
@@ -372,27 +370,27 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 				resolution_width, resolution_height, fps_info.int_array.def);
 
 			if (camera_facing_direction == 1) {
-				if (rcmd_dpy_rotation == MM_DISPLAY_ROTATION_270 || rcmd_dpy_rotation == MM_DISPLAY_ROTATION_90) {
+				if (rcmd_dpy_rotation == MM_DISPLAY_ROTATION_270 || rcmd_dpy_rotation == MM_DISPLAY_ROTATION_90)
 					camera_default_flip = MM_FLIP_VERTICAL;
-				} else {
+				else
 					camera_default_flip = MM_FLIP_HORIZONTAL;
-				}
+
 				_mmcam_dbg_log("camera_default_flip : [%d]", camera_default_flip);
 			}
 
 			mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
-			                            MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
-			                            MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction,
-			                            MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture,
-			                            MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording,
-			                            MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation,
-			                            MMCAM_SUPPORT_ZSL_CAPTURE, hcamcorder->support_zsl_capture,
-			                            MMCAM_SUPPORT_ZERO_COPY_FORMAT, hcamcorder->use_zero_copy_format,
-			                            MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, hcamcorder->support_media_packet_preview_cb,
-			                            MMCAM_CAMERA_FPS, fps_info.int_array.def,
-			                            MMCAM_DISPLAY_FLIP, camera_default_flip,
-			                            "capture-sound-enable", play_capture_sound,
-			                            NULL);
+				MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
+				MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction,
+				MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture,
+				MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording,
+				MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation,
+				MMCAM_SUPPORT_ZSL_CAPTURE, hcamcorder->support_zsl_capture,
+				MMCAM_SUPPORT_ZERO_COPY_FORMAT, hcamcorder->use_zero_copy_format,
+				MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, hcamcorder->support_media_packet_preview_cb,
+				MMCAM_CAMERA_FPS, fps_info.int_array.def,
+				MMCAM_DISPLAY_FLIP, camera_default_flip,
+				"capture-sound-enable", play_capture_sound,
+				NULL);
 			if (err_attr_name) {
 				_mmcam_dbg_err("Set %s FAILED.", err_attr_name);
 				SAFE_FREE(err_attr_name);
@@ -402,8 +400,8 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 
 			/* Get default value of brightness */
 			mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_attr_name,
-			                            MMCAM_FILTER_BRIGHTNESS, &hcamcorder->brightness_default,
-			                            NULL);
+				MMCAM_FILTER_BRIGHTNESS, &hcamcorder->brightness_default,
+				NULL);
 			if (err_attr_name) {
 				_mmcam_dbg_err("Get brightness FAILED.");
 				SAFE_FREE(err_attr_name);
@@ -412,15 +410,15 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 			}
 			_mmcam_dbg_log("Default brightness : %d", hcamcorder->brightness_default);
 		} else {
-			_mmcam_dbg_log( "Disable Configure Control system." );
+			_mmcam_dbg_log("Disable Configure Control system.");
 			hcamcorder->conf_ctrl = NULL;
 		}
 
 		/* add DPM camera policy changed callback */
 		if (hcamcorder->dpm_context) {
-			if (dpm_context_add_policy_changed_cb(hcamcorder->dpm_context,
-				"camera", _mmcamcorder_dpm_camera_policy_changed_cb,
-				(void *)hcamcorder, &hcamcorder->dpm_camera_cb_id) != DPM_ERROR_NONE) {
+			ret = dpm_context_add_policy_changed_cb(hcamcorder->dpm_context, "camera",
+				_mmcamcorder_dpm_camera_policy_changed_cb, (void *)hcamcorder, &hcamcorder->dpm_camera_cb_id);
+			if (ret != DPM_ERROR_NONE) {
 				_mmcam_dbg_err("add DPM changed cb failed, keep going...");
 				hcamcorder->dpm_camera_cb_id = 0;
 			}
@@ -429,12 +427,13 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 		}
 	} else {
 		_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
-			                            CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
-			                            "DeviceCount",
-			                            &camera_device_count);
+			CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+			"DeviceCount",
+			&camera_device_count);
+
 		mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
-			                            MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
-			                            NULL);
+			MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
+			NULL);
 		if (err_attr_name) {
 			_mmcam_dbg_err("Set %s FAILED.", err_attr_name);
 			SAFE_FREE(err_attr_name);
@@ -467,7 +466,7 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 	traceEnd(TTRACE_TAG_CAMERA);
 
 	if (!ret) {
-		_mmcam_dbg_err( "Failed to initialize gstreamer!!" );
+		_mmcam_dbg_err("Failed to initialize gstreamer!!");
 		ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
 		goto _ERR_DEFAULT_VALUE_INIT;
 	}
@@ -480,9 +479,9 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 
 	/* Get videosink name for evas surface */
 	_mmcamcorder_conf_get_element((MMHandleType)hcamcorder, hcamcorder->conf_main,
-	                              CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
-	                              "VideosinkElementEvas",
-	                              &EvasSurfaceElement);
+		CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+		"VideosinkElementEvas",
+		&EvasSurfaceElement);
 	if (EvasSurfaceElement) {
 		int attr_index = 0;
 		const char *evassink_name = NULL;
@@ -564,7 +563,7 @@ _ERR_DEFAULT_VALUE_INIT:
 		}
 	} else {
 		_mmcam_dbg_warn("no need to unregister sound focus[%d, id %d]",
-		               hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
+			hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
 	}
 
 	/* release DPM related handle */
@@ -617,13 +616,11 @@ _ERR_DEFAULT_VALUE_INIT:
 	g_cond_clear(&hcamcorder->snd_info.open_cond);
 	g_mutex_clear(&hcamcorder->restart_preview_lock);
 
-	if (hcamcorder->conf_ctrl) {
+	if (hcamcorder->conf_ctrl)
 		_mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_ctrl);
-	}
 
-	if (hcamcorder->conf_main) {
+	if (hcamcorder->conf_main)
 		_mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_main);
-	}
 
 	if (hcamcorder->model_name) {
 		free(hcamcorder->model_name);
@@ -714,9 +711,8 @@ int _mmcamcorder_destroy(MMHandleType handle)
 
 	/* Release SubContext and pipeline */
 	if (hcamcorder->sub_context) {
-		if (hcamcorder->sub_context->element) {
+		if (hcamcorder->sub_context->element)
 			_mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
-		}
 
 		_mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
 		hcamcorder->sub_context = NULL;
@@ -725,9 +721,8 @@ int _mmcamcorder_destroy(MMHandleType handle)
 #ifdef _MMCAMCORDER_MURPHY_SUPPORT
 	/* de-initialize resource manager */
 	ret = _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		_mmcam_dbg_err("failed to de-initialize resource manager 0x%x", ret);
-	}
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
 	/* Remove idle function which is not called yet */
@@ -746,17 +741,15 @@ int _mmcamcorder_destroy(MMHandleType handle)
 	/* Remove exif info */
 	if (hcamcorder->exif_info) {
 		mm_exif_destory_exif_info(hcamcorder->exif_info);
-		hcamcorder->exif_info=NULL;
-
+		hcamcorder->exif_info = NULL;
 	}
 
 	/* Release configure info */
-	if (hcamcorder->conf_ctrl) {
+	if (hcamcorder->conf_ctrl)
 		_mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl);
-	}
-	if (hcamcorder->conf_main) {
+
+	if (hcamcorder->conf_main)
 		_mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main);
-	}
 
 	/* Remove messages which are not called yet */
 	_mmcamcorder_remove_message_all(handle);
@@ -765,14 +758,14 @@ int _mmcamcorder_destroy(MMHandleType handle)
 	if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) {
 		if (mm_sound_unregister_focus(hcamcorder->sound_focus_id) != MM_ERROR_NONE) {
 			_mmcam_dbg_err("mm_sound_unregister_focus[id %d] failed",
-			               hcamcorder->sound_focus_id);
+				hcamcorder->sound_focus_id);
 		} else {
 			_mmcam_dbg_log("mm_sound_unregister_focus[id %d] done",
-			               hcamcorder->sound_focus_id);
+			hcamcorder->sound_focus_id);
 		}
 	} else {
 		_mmcam_dbg_log("no need to unregister sound focus.[%d, id %d]",
-		               hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
+			hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
 	}
 #ifdef _MMCAMCORDER_RM_SUPPORT
 	if (hcamcorder->rm_handle != 0) {
@@ -857,9 +850,8 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 	_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
 
 _ERR_CAMCORDER_CMD_PRECON:
-	if (hcamcorder) {
+	if (hcamcorder)
 		_mmcam_dbg_err("Destroy fail (type %d, state %d)", hcamcorder->type, state);
-	}
 
 	_mmcam_dbg_err("Destroy fail (ret %x)", ret);
 
@@ -909,8 +901,8 @@ int _mmcamcorder_realize(MMHandleType handle)
 	}
 
 	mm_camcorder_get_attributes(handle, NULL,
-	                            MMCAM_MODE, &hcamcorder->type,
-	                            NULL);
+		MMCAM_MODE, &hcamcorder->type,
+		NULL);
 
 	/* Get profile mode */
 	_mmcam_dbg_log("Profile mode [%d]", hcamcorder->type);
@@ -923,8 +915,8 @@ int _mmcamcorder_realize(MMHandleType handle)
 	/* sound focus */
 	if (hcamcorder->sound_focus_register) {
 		mm_camcorder_get_attributes(handle, NULL,
-		                            MMCAM_PID_FOR_SOUND_FOCUS, &pid_for_sound_focus,
-		                            NULL);
+			MMCAM_PID_FOR_SOUND_FOCUS, &pid_for_sound_focus,
+			NULL);
 
 		if (pid_for_sound_focus == 0) {
 			pid_for_sound_focus = getpid();
@@ -958,10 +950,10 @@ int _mmcamcorder_realize(MMHandleType handle)
 			_mmcam_dbg_log("ETC - set sound focus watch callback - pid %d", pid_for_sound_focus);
 
 			ret_sound = mm_sound_set_focus_watch_callback_for_session(pid_for_sound_focus,
-			                                                          FOCUS_FOR_BOTH,
-			                                                          (mm_sound_focus_changed_watch_cb)_mmcamcorder_sound_focus_watch_cb,
-			                                                          hcamcorder,
-			                                                          &hcamcorder->sound_focus_watch_id);
+				FOCUS_FOR_BOTH,
+				(mm_sound_focus_changed_watch_cb)_mmcamcorder_sound_focus_watch_cb,
+				hcamcorder,
+				&hcamcorder->sound_focus_watch_id);
 			if (ret_sound != MM_ERROR_NONE) {
 				_mmcam_dbg_err("mm_sound_set_focus_watch_callback failed [0x%x]", ret_sound);
 
@@ -985,15 +977,15 @@ int _mmcamcorder_realize(MMHandleType handle)
 	int resource_count = 0;
 
 	mm_camcorder_get_attributes(handle, NULL,
-	                            MMCAM_PID_FOR_SOUND_FOCUS, &app_pid,
-	                            NULL);
+		MMCAM_PID_FOR_SOUND_FOCUS, &app_pid,
+		NULL);
 	rci.app_pid = app_pid;
 	aul_app_get_appid_bypid(rci.app_pid, rci.app_id, sizeof(rci.app_id));
 
 	/* RM register */
 	if (hcamcorder->rm_handle == 0) {
 		iret = rm_register((rm_resource_cb)_mmcamcorder_rm_callback, (void*)hcamcorder,
-		            &(hcamcorder->rm_handle), &rci);
+			&(hcamcorder->rm_handle), &rci);
 		if (iret != RM_OK) {
 			_mmcam_dbg_err("rm_register fail");
 			ret = MM_ERROR_POLICY_BLOCKED;
@@ -1002,24 +994,22 @@ int _mmcamcorder_realize(MMHandleType handle)
 	}
 
 	mm_camcorder_get_attributes(handle, NULL,
-								MMCAM_CAMERA_FORMAT, &preview_format,
-								NULL);
+		MMCAM_CAMERA_FORMAT, &preview_format,
+		NULL);
 
 	if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO && preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
-
 		resource_count = 0;
 		memset(&hcamcorder->request_resources, 0x0, sizeof(rm_category_request_s));
 		memset(&hcamcorder->returned_devices, 0x0, sizeof(rm_device_return_s));
 		hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
 		hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER;
-		_mmcam_dbg_log("request video decoder resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+		_mmcam_dbg_log("request video decoder resource - device category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
 
 		resource_count++;
 		hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
 		hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER;
 		hcamcorder->request_resources.request_num = resource_count + 1;
-		_mmcam_dbg_log("request scaler resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
-
+		_mmcam_dbg_log("request scaler resource - device category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
 
 		qret = rm_query(hcamcorder->rm_handle, RM_QUERY_ALLOCATION, &(hcamcorder->request_resources), &qret_avail);
 
@@ -1028,18 +1018,18 @@ int _mmcamcorder_realize(MMHandleType handle)
 
 			resource_count = 0;
 			hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER_SUB;
-			_mmcam_dbg_log("request video decoder resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+			_mmcam_dbg_log("request video decoder resource - device category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
 
 			resource_count++;
 			hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB;
-			_mmcam_dbg_log("request scaler resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+			_mmcam_dbg_log("request scaler resource - device category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
 		}
 
 		resource_count++;
 		hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
 		hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_CAMERA;
 		hcamcorder->request_resources.request_num = resource_count + 1;
-		_mmcam_dbg_log("request camera resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+		_mmcam_dbg_log("request camera resource - device category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
 
 		iret = rm_allocate_resources(hcamcorder->rm_handle, &(hcamcorder->request_resources), &hcamcorder->returned_devices);
 		if (iret != RM_OK) {
@@ -1052,28 +1042,27 @@ int _mmcamcorder_realize(MMHandleType handle)
 
 	/* alloc sub context */
 	hcamcorder->sub_context = _mmcamcorder_alloc_subcontext(hcamcorder->type);
-	if(!hcamcorder->sub_context) {
+	if (!hcamcorder->sub_context) {
 		ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
 		goto _ERR_CAMCORDER_CMD;
 	}
 
 	/* Set basic configure information */
-	if (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
+	if (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE)
 		hcamcorder->sub_context->is_modified_rate = TRUE;
-	}
 
 	_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
-	                                CONFIGURE_CATEGORY_MAIN_CAPTURE,
-	                                "UseEncodebin",
-	                                &(hcamcorder->sub_context->bencbin_capture));
+		CONFIGURE_CATEGORY_MAIN_CAPTURE,
+		"UseEncodebin",
+		&(hcamcorder->sub_context->bencbin_capture));
 	_mmcam_dbg_warn("UseEncodebin [%d]", hcamcorder->sub_context->bencbin_capture);
 
 	if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
 		/* get dual stream support info */
 		_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
-		                                CONFIGURE_CATEGORY_MAIN_RECORD,
-		                                "SupportDualStream",
-		                                &(hcamcorder->sub_context->info_video->support_dual_stream));
+			CONFIGURE_CATEGORY_MAIN_RECORD,
+			"SupportDualStream",
+			&(hcamcorder->sub_context->info_video->support_dual_stream));
 		_mmcam_dbg_warn("SupportDualStream [%d]", hcamcorder->sub_context->info_video->support_dual_stream);
 	}
 
@@ -1097,8 +1086,9 @@ int _mmcamcorder_realize(MMHandleType handle)
 		if (socket_path == NULL) {
 			_mmcam_dbg_warn("REMOTE surface, but socket path is NULL -> to NullSink");
 			videosink_element_type = strdup("VideosinkElementNull");
-		} else
+		} else {
 			videosink_element_type = strdup("VideosinkElementRemote");
+		}
 		break;
 	default:
 		videosink_element_type = strdup("VideosinkElementOverlay");
@@ -1108,19 +1098,19 @@ int _mmcamcorder_realize(MMHandleType handle)
 	/* check string of videosink element */
 	if (videosink_element_type) {
 		_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-		                              CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
-		                              videosink_element_type,
-		                              &hcamcorder->sub_context->VideosinkElement);
+			CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+			videosink_element_type,
+			&hcamcorder->sub_context->VideosinkElement);
 		free(videosink_element_type);
 		videosink_element_type = NULL;
 	} else {
 		_mmcam_dbg_warn("strdup failed(display_surface_type %d). Use default X type",
-		                display_surface_type);
+			display_surface_type);
 
 		_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-		                              CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
-		                              _MMCAMCORDER_DEFAULT_VIDEOSINK_TYPE,
-		                              &hcamcorder->sub_context->VideosinkElement);
+			CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+			_MMCAMCORDER_DEFAULT_VIDEOSINK_TYPE,
+			&hcamcorder->sub_context->VideosinkElement);
 	}
 
 	_mmcamcorder_conf_get_value_element_name(hcamcorder->sub_context->VideosinkElement, &videosink_name);
@@ -1128,14 +1118,14 @@ int _mmcamcorder_realize(MMHandleType handle)
 
 	/* get videoconvert element */
 	_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-	                              CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
-	                              "VideoconvertElement",
-	                              &hcamcorder->sub_context->VideoconvertElement);
+		CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+		"VideoconvertElement",
+		&hcamcorder->sub_context->VideoconvertElement);
 
 	_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_ctrl,
-	                                CONFIGURE_CATEGORY_CTRL_CAPTURE,
-	                                "SensorEncodedCapture",
-	                                &(hcamcorder->sub_context->SensorEncodedCapture));
+		CONFIGURE_CATEGORY_CTRL_CAPTURE,
+		"SensorEncodedCapture",
+		&(hcamcorder->sub_context->SensorEncodedCapture));
 	_mmcam_dbg_log("Support sensor encoded capture : %d", hcamcorder->sub_context->SensorEncodedCapture);
 
 	if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
@@ -1177,7 +1167,7 @@ int _mmcamcorder_realize(MMHandleType handle)
 
 		if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
 			ret = _mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, MM_CAMCORDER_RESOURCE_TYPE_VIDEO_OVERLAY);
-			if(ret != MM_ERROR_NONE) {
+			if (ret != MM_ERROR_NONE) {
 				_mmcam_dbg_err("could not prepare for video overlay resource");
 				ret = MM_ERROR_CAMCORDER_INTERNAL;
 				goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
@@ -1261,14 +1251,13 @@ _ERR_CAMCORDER_CMD:
 		int ret_resource = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
 		if (ret_resource == MM_ERROR_RESOURCE_INVALID_STATE) {
 			_mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource");
-		}
-		else if (ret_resource != MM_ERROR_NONE) {
+		} else if (ret_resource != MM_ERROR_NONE) {
 			_mmcam_dbg_err("failed to release resource, ret_resource(0x%x)", ret_resource);
 		}
+
 		ret_resource = _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager);
-		if (ret_resource != MM_ERROR_NONE) {
+		if (ret_resource != MM_ERROR_NONE)
 			_mmcam_dbg_err("failed to unprepare resource manager, ret_resource(0x%x)", ret_resource);
-		}
 	}
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
@@ -1278,21 +1267,17 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 	if (hcamcorder->sound_focus_register) {
 		if (hcamcorder->sound_focus_watch_id > 0) {
 			if (mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id) != MM_ERROR_NONE) {
-				_mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] failed",
-				                hcamcorder->sound_focus_watch_id);
+				_mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] failed", hcamcorder->sound_focus_watch_id);
 			} else {
-				_mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] done",
-				                hcamcorder->sound_focus_watch_id);
+				_mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] done", hcamcorder->sound_focus_watch_id);
 			}
 		}
 
 		if (hcamcorder->acquired_focus > 0) {
 				if (mm_sound_release_focus(0, hcamcorder->acquired_focus, NULL) != MM_ERROR_NONE) {
-					_mmcam_dbg_err("mm_sound_release_focus[focus %d] failed",
-					               hcamcorder->acquired_focus);
+					_mmcam_dbg_err("mm_sound_release_focus[focus %d] failed", hcamcorder->acquired_focus);
 				} else {
-					_mmcam_dbg_err("mm_sound_release_focus[focus %d] done",
-					               hcamcorder->acquired_focus);
+					_mmcam_dbg_err("mm_sound_release_focus[focus %d] done", hcamcorder->acquired_focus);
 				}
 		}
 	}
@@ -1303,9 +1288,9 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 			rm_device_request_s requested;
 			memset(&requested, 0x0, sizeof(rm_device_request_s));
 			requested.request_num = hcamcorder->returned_devices.allocated_num;
-			for (idx = 0; idx < requested.request_num; idx++) {
+			for (idx = 0; idx < requested.request_num; idx++)
 				requested.device_id[idx] = hcamcorder->returned_devices.device_id[idx];
-			}
+
 			iret = rm_deallocate_resources(hcamcorder->rm_handle, &requested);
 			if (iret != RM_OK)
 				_mmcam_dbg_err("Resource deallocation request failed ");
@@ -1319,8 +1304,7 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 #endif /* _MMCAMCORDER_RM_SUPPORT*/
 
 _ERR_CAMCORDER_CMD_PRECON:
-	_mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)",
-	               hcamcorder->type, state, ret);
+	_mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret);
 
 	return ret;
 }
@@ -1379,10 +1363,10 @@ int _mmcamcorder_unrealize(MMHandleType handle)
 		}
 		_MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
 		ret = _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager);
+
 		_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			_mmcam_dbg_err("failed to unprepare resource manager, ret(0x%x)", ret);
-		}
 	}
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
@@ -1393,9 +1377,9 @@ int _mmcamcorder_unrealize(MMHandleType handle)
 			rm_device_request_s requested;
 			memset(&requested, 0x0, sizeof(rm_device_request_s));
 			requested.request_num = hcamcorder->returned_devices.allocated_num;
-			for (idx = 0; idx < requested.request_num; idx++) {
+			for (idx = 0; idx < requested.request_num; idx++)
 				requested.device_id[idx] = hcamcorder->returned_devices.device_id[idx];
-			}
+
 			iret = rm_deallocate_resources(hcamcorder->rm_handle, &requested);
 			if (iret != RM_OK)
 				_mmcam_dbg_err("Resource deallocation request failed ");
@@ -1406,41 +1390,38 @@ int _mmcamcorder_unrealize(MMHandleType handle)
 	hcamcorder->command = NULL;
 
 	_mmcam_dbg_log("focus register %d, session flag 0x%x, state_change_by_system %d",
-	               hcamcorder->sound_focus_register, hcamcorder->session_flags, hcamcorder->state_change_by_system);
+		hcamcorder->sound_focus_register, hcamcorder->session_flags, hcamcorder->state_change_by_system);
 
 	/* release sound focus or unset sound focus watch callback */
 	if (hcamcorder->sound_focus_register) {
 		int ret_sound = MM_ERROR_NONE;
 
 		_mmcam_dbg_log("state_change_by_system %d, session flag 0x%x, acquired_focus %d, sound_focus_id %d, sound_focus_watch_id %d",
-		               hcamcorder->state_change_by_system, hcamcorder->session_flags, hcamcorder->acquired_focus,
-		               hcamcorder->sound_focus_id, hcamcorder->sound_focus_watch_id);
+			hcamcorder->state_change_by_system, hcamcorder->session_flags, hcamcorder->acquired_focus,
+			hcamcorder->sound_focus_id, hcamcorder->sound_focus_watch_id);
 
 		if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_FOCUS &&
 		    hcamcorder->sound_focus_watch_id > 0) {
 			ret_sound = mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id);
 			if (ret_sound != MM_ERROR_NONE) {
-				_mmcam_dbg_warn("mm_sound_unset_focus_watch_callback failed [0x%x]",
-				                ret_sound);
+				_mmcam_dbg_warn("mm_sound_unset_focus_watch_callback failed [0x%x]", ret_sound);
 			} else {
 				_mmcam_dbg_warn("mm_sound_unset_focus_watch_callback done");
 			}
 		} else {
 			_mmcam_dbg_warn("no need to unset watch callback.[state_change_by_system %d, sound_focus_watch_id %d]",
-			                hcamcorder->state_change_by_system, hcamcorder->sound_focus_watch_id);
+				hcamcorder->state_change_by_system, hcamcorder->sound_focus_watch_id);
 		}
 
 		if (hcamcorder->acquired_focus > 0) {
 			ret_sound = mm_sound_release_focus(0, hcamcorder->acquired_focus, NULL);
 			if (ret_sound != MM_ERROR_NONE) {
-				_mmcam_dbg_warn("mm_sound_release_focus failed [0x%x]",
-				                ret_sound);
+				_mmcam_dbg_warn("mm_sound_release_focus failed [0x%x]", ret_sound);
 			} else {
 				_mmcam_dbg_log("mm_sound_release_focus done");
 			}
 		} else {
-			_mmcam_dbg_warn("no need to release focus - current acquired focus %d",
-			                hcamcorder->acquired_focus);
+			_mmcam_dbg_warn("no need to release focus - current acquired focus %d", hcamcorder->acquired_focus);
 		}
 	}
 
@@ -1455,8 +1436,7 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 
 _ERR_CAMCORDER_CMD_PRECON:
 	/* send message */
-	_mmcam_dbg_err("Unrealize fail (type %d, state %d, ret %x)",
-	               hcamcorder->type, state, ret);
+	_mmcam_dbg_err("Unrealize fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret);
 
 	return ret;
 }
@@ -1466,7 +1446,7 @@ int _mmcamcorder_start(MMHandleType handle)
 	int ret = MM_ERROR_NONE;
 	int state = MM_CAMCORDER_STATE_NONE;
 	int state_FROM = MM_CAMCORDER_STATE_READY;
-	int state_TO =MM_CAMCORDER_STATE_PREPARE;
+	int state_TO = MM_CAMCORDER_STATE_PREPARE;
 
 	_MMCamcorderSubContext *sc = NULL;
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
@@ -1555,7 +1535,7 @@ _ERR_CAMCORDER_CMD_PRECON:
 	}
 
 	_mmcam_dbg_err("Start fail (type %d, state %d, ret %x)",
-	               hcamcorder->type, state, ret);
+				   hcamcorder->type, state, ret);
 
 	return ret;
 }
@@ -1591,28 +1571,23 @@ int _mmcamcorder_stop(MMHandleType handle)
 	}
 
 	ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_STOP);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
-	}
 
 	_mmcamcorder_set_state(handle, state_TO);
 
 	if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
 		g_mutex_lock(&hcamcorder->gdbus_info_sound.sync_mutex);
 		if (hcamcorder->gdbus_info_sound.subscribe_id > 0) {
-			_mmcam_dbg_warn("subscribe_id[%u] is remained. remove it.",
-				hcamcorder->gdbus_info_sound.subscribe_id);
-			g_dbus_connection_signal_unsubscribe(hcamcorder->gdbus_conn,
-				hcamcorder->gdbus_info_sound.subscribe_id);
+			_mmcam_dbg_warn("subscribe_id[%u] is remained. remove it.", hcamcorder->gdbus_info_sound.subscribe_id);
+			g_dbus_connection_signal_unsubscribe(hcamcorder->gdbus_conn, hcamcorder->gdbus_info_sound.subscribe_id);
 		}
 		g_mutex_unlock(&hcamcorder->gdbus_info_sound.sync_mutex);
 
 		g_mutex_lock(&hcamcorder->gdbus_info_solo_sound.sync_mutex);
 		if (hcamcorder->gdbus_info_solo_sound.subscribe_id > 0) {
-			_mmcam_dbg_warn("subscribe_id[%u] is remained. remove it.",
-				hcamcorder->gdbus_info_solo_sound.subscribe_id);
-			g_dbus_connection_signal_unsubscribe(hcamcorder->gdbus_conn,
-				hcamcorder->gdbus_info_solo_sound.subscribe_id);
+			_mmcam_dbg_warn("subscribe_id[%u] is remained. remove it.", hcamcorder->gdbus_info_solo_sound.subscribe_id);
+			g_dbus_connection_signal_unsubscribe(hcamcorder->gdbus_conn, hcamcorder->gdbus_info_solo_sound.subscribe_id);
 		}
 		g_mutex_unlock(&hcamcorder->gdbus_info_solo_sound.sync_mutex);
 
@@ -1634,8 +1609,7 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 
 _ERR_CAMCORDER_CMD_PRECON:
 	/* send message */
-	_mmcam_dbg_err("Stop fail (type %d, state %d, ret %x)",
-	               hcamcorder->type, state, ret);
+	_mmcam_dbg_err("Stop fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret);
 
 	return ret;
 }
@@ -1667,9 +1641,7 @@ int _mmcamcorder_capture_start(MMHandleType handle)
 	}
 
 	state = _mmcamcorder_get_state(handle);
-	if (state != state_FROM_0 &&
-	    state != state_FROM_1 &&
-	    state != state_FROM_2) {
+	if (state != state_FROM_0 && state != state_FROM_1 && state != state_FROM_2) {
 		_mmcam_dbg_err("Wrong state(%d)", state);
 		ret = MM_ERROR_CAMCORDER_INVALID_STATE;
 		goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
@@ -1699,28 +1671,24 @@ int _mmcamcorder_capture_start(MMHandleType handle)
 	}
 
 	ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CAPTURE);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		goto _ERR_CAMCORDER_CMD;
-	}
 
 	/* Do not change state when recording snapshot capture */
-	if (state == state_FROM_0) {
+	if (state == state_FROM_0)
 		_mmcamcorder_set_state(handle, state_TO);
-	}
 
 	_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
 
 	/* Init break continuous shot attr */
-	if (mm_camcorder_set_attributes(handle, NULL, "capture-break-cont-shot", 0, NULL) != MM_ERROR_NONE) {
+	if (mm_camcorder_set_attributes(handle, NULL, "capture-break-cont-shot", 0, NULL) != MM_ERROR_NONE)
 		_mmcam_dbg_warn("capture-break-cont-shot set 0 failed");
-	}
 
 	return MM_ERROR_NONE;
 
 _ERR_CAMCORDER_CMD:
-	if (hcamcorder->capture_in_recording) {
+	if (hcamcorder->capture_in_recording)
 		hcamcorder->capture_in_recording = FALSE;
-	}
 
 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 	_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
@@ -1728,7 +1696,7 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 _ERR_CAMCORDER_CMD_PRECON:
 	/* send message */
 	_mmcam_dbg_err("Capture start fail (type %d, state %d, ret %x)",
-	               hcamcorder->type, state, ret);
+		hcamcorder->type, state, ret);
 
 	return ret;
 }
@@ -1763,9 +1731,8 @@ int _mmcamcorder_capture_stop(MMHandleType handle)
 	}
 
 	ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_START);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
-	}
 
 	_mmcamcorder_set_state(handle, state_TO);
 
@@ -1779,7 +1746,7 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 _ERR_CAMCORDER_CMD_PRECON:
 	/* send message */
 	_mmcam_dbg_err("Capture stop fail (type %d, state %d, ret %x)",
-	               hcamcorder->type, state, ret);
+		hcamcorder->type, state, ret);
 
 	return ret;
 }
@@ -1864,7 +1831,7 @@ _ERR_CAMCORDER_CMD_PRECON:
 	}
 
 	_mmcam_dbg_err("Record fail (type %d, state %d, ret %x)",
-	               hcamcorder->type, state, ret);
+				   hcamcorder->type, state, ret);
 
 	return ret;
 }
@@ -1901,9 +1868,8 @@ int _mmcamcorder_pause(MMHandleType handle)
 	}
 
 	ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PAUSE);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
-	}
 
 	_mmcamcorder_set_state(handle, state_TO);
 
@@ -1916,8 +1882,7 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 
 _ERR_CAMCORDER_CMD_PRECON:
 	/* send message */
-	_mmcam_dbg_err("Pause fail (type %d, state %d, ret %x)",
-	               hcamcorder->type, state, ret);
+	_mmcam_dbg_err("Pause fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret);
 
 	return ret;
 }
@@ -1958,13 +1923,12 @@ int _mmcamcorder_commit(MMHandleType handle)
 	hcamcorder->error_code = MM_ERROR_NONE;
 
 	ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_COMMIT);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
-	}
 
 	_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
 
-	_mmcamcorder_set_state(handle,state_TO);
+	_mmcamcorder_set_state(handle, state_TO);
 
 	return MM_ERROR_NONE;
 
@@ -1973,8 +1937,7 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 
 _ERR_CAMCORDER_CMD_PRECON:
 	/* send message */
-	_mmcam_dbg_err("Commit fail (type %d, state %d, ret %x)",
-	               hcamcorder->type, state, ret);
+	_mmcam_dbg_err("Commit fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret);
 
 	return ret;
 }
@@ -2012,9 +1975,8 @@ int _mmcamcorder_cancel(MMHandleType handle)
 	}
 
 	ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CANCEL);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
-	}
 
 	_mmcamcorder_set_state(handle, state_TO);
 
@@ -2028,7 +1990,7 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 _ERR_CAMCORDER_CMD_PRECON:
 	/* send message */
 	_mmcam_dbg_err("Cancel fail (type %d, state %d, ret %x)",
-	               hcamcorder->type, state, ret);
+				   hcamcorder->type, state, ret);
 
 	return ret;
 }
@@ -2054,9 +2016,8 @@ int _mmcamcorder_set_message_callback(MMHandleType handle, MMMessageCallback cal
 
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
-	if (callback == NULL) {
+	if (callback == NULL)
 		_mmcam_dbg_warn("Message Callback is disabled, because application sets it to NULL");
-	}
 
 	if (!_MMCAMCORDER_TRYLOCK_MESSAGE_CALLBACK(hcamcorder)) {
 		_mmcam_dbg_warn("Application's message callback is running now");
@@ -2081,9 +2042,8 @@ int _mmcamcorder_set_video_stream_callback(MMHandleType handle, mm_camcorder_vid
 
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
-	if (callback == NULL) {
+	if (callback == NULL)
 		_mmcam_dbg_warn("Video Stream Callback is disabled, because application sets it to NULL");
-	}
 
 	if (!_MMCAMCORDER_TRYLOCK_VSTREAM_CALLBACK(hcamcorder)) {
 		_mmcam_dbg_warn("Application's video stream callback is running now");
@@ -2107,9 +2067,8 @@ int _mmcamcorder_set_audio_stream_callback(MMHandleType handle, mm_camcorder_aud
 
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
-	if (callback == NULL) {
+	if (callback == NULL)
 		_mmcam_dbg_warn("Audio Stream Callback is disabled, because application sets it to NULL");
-	}
 
 	if (!_MMCAMCORDER_TRYLOCK_ASTREAM_CALLBACK(hcamcorder)) {
 		_mmcam_dbg_warn("Application's audio stream callback is running now");
@@ -2133,9 +2092,8 @@ int _mmcamcorder_set_video_capture_callback(MMHandleType handle, mm_camcorder_vi
 
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
-	if (callback == NULL) {
+	if (callback == NULL)
 		_mmcam_dbg_warn("Video Capture Callback is disabled, because application sets it to NULLL");
-	}
 
 	if (!_MMCAMCORDER_TRYLOCK_VCAPTURE_CALLBACK(hcamcorder)) {
 		_mmcam_dbg_warn("Application's video capture callback is running now");
@@ -2192,7 +2150,7 @@ int _mmcamcorder_init_focusing(MMHandleType handle)
 
 	if (state == MM_CAMCORDER_STATE_CAPTURING ||
 	    state < MM_CAMCORDER_STATE_PREPARE) {
-		_mmcam_dbg_err( "Not proper state. state[%d]", state );
+		_mmcam_dbg_err("Not proper state. state[%d]", state);
 		_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
 		return MM_ERROR_CAMCORDER_INVALID_STATE;
 	}
@@ -2203,7 +2161,7 @@ int _mmcamcorder_init_focusing(MMHandleType handle)
 		return MM_ERROR_NONE;
 	}
 
-	control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+	control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
 	if (control == NULL) {
 		_mmcam_dbg_err("cast CAMERA_CONTROL failed");
 		_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
@@ -2219,19 +2177,18 @@ int _mmcamcorder_init_focusing(MMHandleType handle)
 
 	/* Initialize lens position */
 	mm_camcorder_get_attributes(handle, NULL,
-	                            MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
-	                            MMCAM_CAMERA_AF_SCAN_RANGE, &af_range,
-	                            NULL);
+		MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
+		MMCAM_CAMERA_AF_SCAN_RANGE, &af_range,
+		NULL);
 	sensor_af_range = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_AF_SCAN_RANGE, af_range);
 	sensor_focus_mode = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_FOCUS_MODE, focus_mode);
 
 	gst_camera_control_get_focus(control, &current_focus_mode, &current_af_range);
 
-	if (current_focus_mode != sensor_focus_mode ||
-	    current_af_range != sensor_af_range) {
+	if (current_focus_mode != sensor_focus_mode || current_af_range != sensor_af_range) {
 		ret = gst_camera_control_set_focus(control, sensor_focus_mode, sensor_af_range);
 	} else {
-		_mmcam_dbg_log("No need to init FOCUS [mode:%d, range:%d]", focus_mode, af_range );
+		_mmcam_dbg_log("No need to init FOCUS [mode:%d, range:%d]", focus_mode, af_range);
 		ret = TRUE;
 	}
 
@@ -2264,8 +2221,7 @@ int _mmcamcorder_adjust_focus(MMHandleType handle, int direction)
 	}
 
 	state = _mmcamcorder_get_state(handle);
-	if (state == MM_CAMCORDER_STATE_CAPTURING ||
-	    state < MM_CAMCORDER_STATE_PREPARE) {
+	if (state == MM_CAMCORDER_STATE_CAPTURING || state < MM_CAMCORDER_STATE_PREPARE) {
 		_mmcam_dbg_err("Not proper state. state[%d]", state);
 		_MMCAMCORDER_UNLOCK_CMD(handle);
 		return MM_ERROR_CAMCORDER_INVALID_STATE;
@@ -2273,22 +2229,25 @@ int _mmcamcorder_adjust_focus(MMHandleType handle, int direction)
 
 	/* TODO : call a auto or manual focus function */
 	ret = mm_camcorder_get_attributes(handle, &err_attr_name,
-	                                  MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
-	                                  NULL);
+		MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
+		NULL);
 	if (ret != MM_ERROR_NONE) {
 		_mmcam_dbg_warn("Get focus-mode fail. (%s:%x)", err_attr_name, ret);
-		SAFE_FREE (err_attr_name);
+		SAFE_FREE(err_attr_name);
 		_MMCAMCORDER_UNLOCK_CMD(handle);
 		return ret;
 	}
 
-	if (focus_mode == MM_CAMCORDER_FOCUS_MODE_MANUAL) {
+	switch (focus_mode) {
+	case MM_CAMCORDER_FOCUS_MODE_MANUAL:
 		ret = _mmcamcorder_adjust_manual_focus(handle, direction);
-	} else if (focus_mode == MM_CAMCORDER_FOCUS_MODE_AUTO ||
-		   focus_mode == MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO ||
-		   focus_mode == MM_CAMCORDER_FOCUS_MODE_CONTINUOUS) {
+		break;
+	case MM_CAMCORDER_FOCUS_MODE_AUTO:
+	case MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO:
+	case MM_CAMCORDER_FOCUS_MODE_CONTINUOUS:
 		ret = _mmcamcorder_adjust_auto_focus(handle);
-	} else {
+		break;
+	default:
 		_mmcam_dbg_err("It doesn't adjust focus. Focusing mode(%d)", focus_mode);
 		ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
 	}
@@ -2314,8 +2273,8 @@ int _mmcamcorder_adjust_manual_focus(MMHandleType handle, int direction)
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 	mmf_return_val_if_fail(_MMFCAMCORDER_FOCUS_TOTAL_LEVEL != 1, MM_ERROR_CAMCORDER_NOT_SUPPORTED);
 	mmf_return_val_if_fail((direction >= MM_CAMCORDER_MF_LENS_DIR_FORWARD) &&
-	                       (direction <= MM_CAMCORDER_MF_LENS_DIR_BACKWARD),
-	                       MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
+		(direction <= MM_CAMCORDER_MF_LENS_DIR_BACKWARD),
+		MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
 	mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
@@ -2325,16 +2284,15 @@ int _mmcamcorder_adjust_manual_focus(MMHandleType handle, int direction)
 		return MM_ERROR_NONE;
 	}
 
-	control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+	control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
 	if (control == NULL) {
 		_mmcam_dbg_err("cast CAMERA_CONTROL failed");
 		return MM_ERROR_CAMCORDER_INTERNAL;
 	}
 
 	/* TODO : get max, min level */
-	if (max_level - min_level + 1 < _MMFCAMCORDER_FOCUS_TOTAL_LEVEL) {
+	if (max_level - min_level + 1 < _MMFCAMCORDER_FOCUS_TOTAL_LEVEL)
 		_mmcam_dbg_warn("Total level  of manual focus of MMF is greater than that of the camera driver.");
-	}
 
 	unit_level = ((float)max_level - (float)min_level)/(float)(_MMFCAMCORDER_FOCUS_TOTAL_LEVEL - 1);
 
@@ -2343,18 +2301,16 @@ int _mmcamcorder_adjust_manual_focus(MMHandleType handle, int direction)
 		return MM_ERROR_CAMCORDER_DEVICE_IO;
 	}
 
-	//TODO : adjust unit level value
-	if (direction == MM_CAMCORDER_MF_LENS_DIR_FORWARD) {
+	/* TODO : adjust unit level value */
+	if (direction == MM_CAMCORDER_MF_LENS_DIR_FORWARD)
 		focus_level = cur_level + unit_level;
-	} else if (direction == MM_CAMCORDER_MF_LENS_DIR_BACKWARD) {
+	else if (direction == MM_CAMCORDER_MF_LENS_DIR_BACKWARD)
 		focus_level = cur_level - unit_level;
-	}
 
-	if (focus_level > max_level) {
+	if (focus_level > max_level)
 		focus_level = max_level;
-	} else if (focus_level < min_level) {
+	else if (focus_level < min_level)
 		focus_level = min_level;
-	}
 
 	if (!gst_camera_control_set_focus_level(control, focus_level)) {
 		_mmcam_dbg_err("Manual focusing fail.");
@@ -2383,7 +2339,7 @@ int _mmcamcorder_adjust_auto_focus(MMHandleType handle)
 		return MM_ERROR_NONE;
 	}
 
-	control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+	control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
 	if (control) {
 		/* Start AF */
 		ret = gst_camera_control_start_auto_focus(control);
@@ -2421,9 +2377,8 @@ int _mmcamcorder_stop_focusing(MMHandleType handle)
 	}
 
 	state = _mmcamcorder_get_state(handle);
-	if (state == MM_CAMCORDER_STATE_CAPTURING ||
-	    state < MM_CAMCORDER_STATE_PREPARE) {
-		_mmcam_dbg_err( "Not proper state. state[%d]", state );
+	if (state == MM_CAMCORDER_STATE_CAPTURING || state < MM_CAMCORDER_STATE_PREPARE) {
+		_mmcam_dbg_err("Not proper state. state[%d]", state);
 		_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
 		return MM_ERROR_CAMCORDER_INVALID_STATE;
 	}
@@ -2477,9 +2432,8 @@ __mmcamcorder_gstreamer_init(camera_conf * conf)
 	argc = malloc(sizeof(int));
 	argv = malloc(sizeof(gchar *) * max_argc);
 
-	if (!argc || !argv) {
+	if (!argc || !argv)
 		goto ERROR;
-	}
 
 	memset(argv, 0, sizeof(gchar *) * max_argc);
 
@@ -2489,31 +2443,26 @@ __mmcamcorder_gstreamer_init(camera_conf * conf)
 
 	/* add gst_param */
 	_mmcamcorder_conf_get_value_string_array(conf,
-	                                         CONFIGURE_CATEGORY_MAIN_GENERAL,
-	                                         "GSTInitOption",
-	                                         &GSTInitOption);
+		CONFIGURE_CATEGORY_MAIN_GENERAL,
+		"GSTInitOption",
+		&GSTInitOption);
 	if (GSTInitOption != NULL && GSTInitOption->value) {
 		cnt_str = GSTInitOption->count;
-		for( ; *argc < max_argc && *argc <= cnt_str ; (*argc)++ )
-		{
+		for ( ; *argc < max_argc && *argc <= cnt_str ; (*argc)++)
 			argv[*argc] = g_strdup(GSTInitOption->value[(*argc)-1]);
-		}
 	}
 
 	_mmcam_dbg_log("initializing gstreamer with following parameter[argc:%d]", *argc);
 
-	for (i = 0; i < *argc; i++) {
+	for (i = 0; i < *argc; i++)
 		_mmcam_dbg_log("argv[%d] : %s", i, argv[i]);
-	}
 
 	/* initializing gstreamer */
-	ret = gst_init_check (argc, &argv, &err);
+	ret = gst_init_check(argc, &argv, &err);
 	if (!ret) {
-		_mmcam_dbg_err("Could not initialize GStreamer: %s ",
-		               err ? err->message : "unknown error occurred");
-		if (err) {
-			g_error_free (err);
-		}
+		_mmcam_dbg_err("Could not initialize GStreamer: %s ", err ? err->message : "unknown error occurred");
+		if (err)
+			g_error_free(err);
 	}
 
 	/* release */
@@ -2584,7 +2533,7 @@ void _mmcamcorder_set_state(MMHandleType handle, int state)
 	_MMCAMCORDER_LOCK_STATE(handle);
 
 	old_state = hcamcorder->state;
-	if(old_state != state) {
+	if (old_state != state) {
 		hcamcorder->state = state;
 		hcamcorder->target_state = state;
 
@@ -2658,16 +2607,16 @@ _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type)
 	/* alloc info for each mode */
 	switch (type) {
 	case MM_CAMCORDER_MODE_AUDIO:
-		sc->info_audio = g_malloc0( sizeof(_MMCamcorderAudioInfo));
-		if(!sc->info_audio) {
+		sc->info_audio = g_malloc0(sizeof(_MMCamcorderAudioInfo));
+		if (!sc->info_audio) {
 			_mmcam_dbg_err("Failed to alloc info structure");
 			goto ALLOC_SUBCONTEXT_FAILED;
 		}
 		break;
 	case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
 	default:
-		sc->info_image = g_malloc0( sizeof(_MMCamcorderImageInfo));
-		if(!sc->info_image) {
+		sc->info_image = g_malloc0(sizeof(_MMCamcorderImageInfo));
+		if (!sc->info_image) {
 			_mmcam_dbg_err("Failed to alloc info structure");
 			goto ALLOC_SUBCONTEXT_FAILED;
 		}
@@ -2675,8 +2624,8 @@ _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type)
 		/* init sound status */
 		sc->info_image->sound_status = _SOUND_STATUS_INIT;
 
-		sc->info_video = g_malloc0( sizeof(_MMCamcorderVideoInfo));
-		if(!sc->info_video) {
+		sc->info_video = g_malloc0(sizeof(_MMCamcorderVideoInfo));
+		if (!sc->info_video) {
 			_mmcam_dbg_err("Failed to alloc info structure");
 			goto ALLOC_SUBCONTEXT_FAILED;
 		}
@@ -2686,13 +2635,13 @@ _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type)
 
 	/* alloc element array */
 	sc->element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->element_num);
-	if(!sc->element) {
+	if (!sc->element) {
 		_mmcam_dbg_err("Failed to alloc element structure");
 		goto ALLOC_SUBCONTEXT_FAILED;
 	}
 
 	sc->encode_element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->encode_element_num);
-	if(!sc->encode_element) {
+	if (!sc->encode_element) {
 		_mmcam_dbg_err("Failed to alloc encode element structure");
 		goto ALLOC_SUBCONTEXT_FAILED;
 	}
@@ -2719,9 +2668,9 @@ ALLOC_SUBCONTEXT_FAILED:
 	if (sc) {
 		SAFE_G_FREE(sc->info_audio);
 		SAFE_G_FREE(sc->info_image);
-		if (sc->info_video) {
+		if (sc->info_video)
 			g_mutex_clear(&sc->info_video->size_check_lock);
-		}
+
 		SAFE_G_FREE(sc->info_video);
 		if (sc->element) {
 			free(sc->element);
@@ -2812,7 +2761,7 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi
 
 	mmf_return_val_if_fail(hcamcorder, FALSE);
 	mmf_return_val_if_fail(message, FALSE);
-	//_mmcam_dbg_log("message type=(%d)", GST_MESSAGE_TYPE(message));
+	/* _mmcam_dbg_log("message type=(%d)", GST_MESSAGE_TYPE(message)); */
 
 	switch (GST_MESSAGE_TYPE(message)) {
 	case GST_MESSAGE_UNKNOWN:
@@ -2850,14 +2799,14 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi
 	{
 		GError *err;
 		gchar *debug;
-		gst_message_parse_warning (message, &err, &debug);
+		gst_message_parse_warning(message, &err, &debug);
 
 		_mmcam_dbg_warn("GSTWARN: %s", err->message);
 
 		__mmcamcorder_handle_gst_warning((MMHandleType)hcamcorder, message, err);
 
-		g_error_free (err);
-		g_free (debug);
+		g_error_free(err);
+		g_free(debug);
 		break;
 	}
 	case GST_MESSAGE_INFO:
@@ -2882,7 +2831,7 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi
 				if (message->src == (GstObject*)pipeline) {
 					vnewstate = gst_structure_get_value(gst_message_get_structure(message), "new-state");
 					newstate = (GstState)vnewstate->data[0].v_int;
-					_mmcam_dbg_log("GST_MESSAGE_STATE_CHANGED[%s]",gst_element_state_get_name(newstate));
+					_mmcam_dbg_log("GST_MESSAGE_STATE_CHANGED[%s]", gst_element_state_get_name(newstate));
 				}
 			}
 		}
@@ -2941,7 +2890,7 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi
 		_mmcam_dbg_log("GST_MESSAGE_ANY");
 		break;
 	case GST_MESSAGE_QOS:
-//		_mmcam_dbg_log("GST_MESSAGE_QOS");
+		/* _mmcam_dbg_log("GST_MESSAGE_QOS"); */
 		break;
 	default:
 		_mmcam_dbg_log("not handled message type=(%d)", GST_MESSAGE_TYPE(message));
@@ -2986,8 +2935,7 @@ GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage
 		element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
 
 		/* check domain[RESOURCE] and element[VIDEOSRC] */
-		if (err->domain == GST_RESOURCE_ERROR &&
-		    GST_ELEMENT_CAST(message->src) == element) {
+		if (err->domain == GST_RESOURCE_ERROR && GST_ELEMENT_CAST(message->src) == element) {
 			switch (err->code) {
 			case GST_RESOURCE_ERROR_BUSY:
 				_mmcam_dbg_err("Camera device [busy]");
@@ -2996,7 +2944,7 @@ GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage
 			case GST_RESOURCE_ERROR_OPEN_WRITE:
 				_mmcam_dbg_err("Camera device [open failed]");
 				hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
-				//sc->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN; // SECURITY PART REQUEST PRIVILEGE
+				/* sc->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN; // SECURITY PART REQUEST PRIVILEGE */
 				break;
 			case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
 				_mmcam_dbg_err("Camera device [open failed]");
@@ -3080,9 +3028,8 @@ GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage
 			GstCameraControlFaceDetectInfo *fd_info = NULL;
 			MMCamFaceDetectInfo *cam_fd_info = NULL;
 
-			if (g_value) {
+			if (g_value)
 				fd_info = (GstCameraControlFaceDetectInfo *)g_value_get_pointer(g_value);
-			}
 
 			if (fd_info == NULL) {
 				_mmcam_dbg_warn("fd_info is NULL");
@@ -3112,12 +3059,12 @@ GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage
 						cam_fd_info->face_info[i].rect.height = fd_info->face_info[i].rect.height;
 						/*
 						_mmcam_dbg_log("id %d, score %d, [%d,%d,%dx%d]",
-						               fd_info->face_info[i].id,
-						               fd_info->face_info[i].score,
-						               fd_info->face_info[i].rect.x,
-						               fd_info->face_info[i].rect.y,
-						               fd_info->face_info[i].rect.width,
-						               fd_info->face_info[i].rect.height);
+							fd_info->face_info[i].id,
+							fd_info->face_info[i].score,
+							fd_info->face_info[i].rect.x,
+							fd_info->face_info[i].rect.y,
+							fd_info->face_info[i].rect.width,
+							fd_info->face_info[i].rect.height);
 						*/
 					}
 				} else {
@@ -3311,8 +3258,8 @@ DROP_MESSAGE:
 
 
 void _mmcamcorder_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)
 {
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data);
 	int current_state = MM_CAMCORDER_STATE_NONE;
@@ -3320,14 +3267,13 @@ void _mmcamcorder_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
 	mmf_return_if_fail((MMHandleType)hcamcorder);
 
 	current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
-	if (current_state <= MM_CAMCORDER_STATE_NONE ||
-	    current_state >= MM_CAMCORDER_STATE_NUM) {
+	if (current_state <= MM_CAMCORDER_STATE_NONE || current_state >= MM_CAMCORDER_STATE_NUM) {
 		_mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state);
 		return;
 	}
 
 	_mmcam_dbg_log("sound focus callback : focus state %d, reason %s",
-	               focus_state, reason_for_change ? reason_for_change : "N/A");
+				   focus_state, reason_for_change ? reason_for_change : "N/A");
 
 	if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
 		_mmcam_dbg_warn("session flag is UNINTERRUPTIBLE. do nothing.");
@@ -3355,7 +3301,7 @@ void _mmcamcorder_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
 		hcamcorder->acquired_focus &= ~focus_type;
 
 		_mmcam_dbg_log("FOCUS is released [type %d, remained focus %d] : Stop pipeline[state:%d]",
-		               focus_type, hcamcorder->acquired_focus, current_state);
+			focus_type, hcamcorder->acquired_focus, current_state);
 
 		__mmcamcorder_force_stop(hcamcorder);
 
@@ -3366,7 +3312,7 @@ void _mmcamcorder_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
 		hcamcorder->acquired_focus |= focus_type;
 
 		_mmcam_dbg_log("FOCUS is acquired [type %d, new focus %d]",
-		               focus_type, hcamcorder->acquired_focus);
+			focus_type, hcamcorder->acquired_focus);
 
 		msg.id = MM_MESSAGE_READY_TO_RESUME;
 		_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
@@ -3386,7 +3332,7 @@ void _mmcamcorder_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
 
 
 void _mmcamcorder_sound_focus_watch_cb(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)
+	const char *reason_for_change, const char *additional_info, void *user_data)
 {
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data);
 	int current_state = MM_CAMCORDER_STATE_NONE;
@@ -3401,7 +3347,7 @@ void _mmcamcorder_sound_focus_watch_cb(mm_sound_focus_type_e focus_type, mm_soun
 	}
 
 	_mmcam_dbg_log("sound focus watch callback : focus state %d, reason %s",
-		       focus_state, reason_for_change ? reason_for_change : "N/A");
+		focus_state, reason_for_change ? reason_for_change : "N/A");
 
 	if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
 		_mmcam_dbg_warn("session flag is UNINTERRUPTIBLE. do nothing.");
@@ -3462,8 +3408,7 @@ void _mmcamcorder_dpm_camera_policy_changed_cb(const char *name, const char *val
 	mmf_return_if_fail(value);
 
 	current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
-	if (current_state <= MM_CAMCORDER_STATE_NONE ||
-	    current_state >= MM_CAMCORDER_STATE_NUM) {
+	if (current_state <= MM_CAMCORDER_STATE_NONE || current_state >= MM_CAMCORDER_STATE_NUM) {
 		_mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state);
 		return;
 	}
@@ -3507,23 +3452,21 @@ int _mmcamcorder_create_pipeline(MMHandleType handle, int type)
 	switch (type) {
 	case MM_CAMCORDER_MODE_AUDIO:
 		ret = _mmcamcorder_create_audio_pipeline(handle);
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			return ret;
-		}
+
 		break;
 	case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
 	default:
 		ret = _mmcamcorder_create_preview_pipeline(handle);
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			return ret;
-		}
 
 		/* connect capture signal */
 		if (!sc->bencbin_capture) {
 			ret = _mmcamcorder_connect_capture_signal(handle);
-			if (ret != MM_ERROR_NONE) {
+			if (ret != MM_ERROR_NONE)
 				return ret;
-			}
 		}
 		break;
 	}
@@ -3537,9 +3480,8 @@ int _mmcamcorder_create_pipeline(MMHandleType handle, int type)
 		traceEnd(TTRACE_TAG_CAMERA);
 	}
 #ifdef _MMCAMCORDER_GET_DEVICE_INFO
-	if (!_mmcamcorder_get_device_info(handle)) {
+	if (!_mmcamcorder_get_device_info(handle))
 		_mmcam_dbg_err("Getting device information error!!");
-	}
 #endif
 
 	_mmcam_dbg_log("ret[%x]", ret);
@@ -3600,22 +3542,22 @@ void _mmcamcorder_destroy_pipeline(MMHandleType handle, int type)
 		GstMessage *gst_msg = NULL;
 		while ((gst_msg = gst_bus_pop(bus)) != NULL) {
 			_mmcamcorder_pipeline_cb_message(bus, gst_msg, (gpointer)hcamcorder);
-			gst_message_unref( gst_msg );
+			gst_message_unref(gst_msg);
 			gst_msg = NULL;
 		}
-		gst_object_unref( bus );
+		gst_object_unref(bus);
 		bus = NULL;
 	}
 
 	/* checking unreleased element */
-	for (i = 0 ; i < element_num ; i++ ) {
+	for (i = 0 ; i < element_num ; i++) {
 		if (element[i].gst) {
 			if (GST_IS_ELEMENT(element[i].gst)) {
 				_mmcam_dbg_warn("Still alive element - ID[%d], name [%s], ref count[%d], status[%s]",
-				                element[i].id,
-				                GST_OBJECT_NAME(element[i].gst),
-				                GST_OBJECT_REFCOUNT(element[i].gst),
-				                gst_element_state_get_name(GST_STATE(element[i].gst)));
+					element[i].id,
+					GST_OBJECT_NAME(element[i].gst),
+					GST_OBJECT_REFCOUNT(element[i].gst),
+					gst_element_state_get_name(GST_STATE(element[i].gst)));
 				g_object_weak_unref(G_OBJECT(element[i].gst), (GWeakNotify)_mmcamcorder_element_release_noti, sc);
 			} else {
 				_mmcam_dbg_warn("The element[%d] is still aliving, check it", element[i].id);
@@ -3690,8 +3632,8 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta
 
 	for (k = 0; k < _MMCAMCORDER_STATE_SET_COUNT; k++) {
 		setChangeReturn = gst_element_set_state(pipeline, target_state);
-		_mmcam_dbg_log("gst_element_set_state[%d] return %d",
-		               target_state, setChangeReturn);
+		_mmcam_dbg_log("gst_element_set_state[%d] return %d", target_state, setChangeReturn);
+
 		if (setChangeReturn != GST_STATE_CHANGE_FAILURE) {
 			getChangeReturn = gst_element_get_state(pipeline, &pipeline_state, NULL, get_timeout);
 			switch (getChangeReturn) {
@@ -3824,20 +3766,17 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
 
 			/* if caturing isn't finished, waiting for 2 sec to finish real capture operation. check 'info->capturing'. */
 			mm_camcorder_set_attributes((MMHandleType)hcamcorder, NULL,
-			                            MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT, TRUE,
-			                            NULL);
+				MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT, TRUE,
+				NULL);
 
-			for (i = 0; i < 20 && info->capturing; i++) {
+			for (i = 0; i < 20 && info->capturing; i++)
 				usleep(100000);
-			}
 
-			if (i == 20) {
+			if (i == 20)
 				_mmcam_dbg_err("Timeout. Can't check stop capturing.");
-			}
 
-			while ((itr_cnt--) && ((result = _mmcamcorder_capture_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
-					_mmcam_dbg_warn("Can't stop capturing.(%x)", result);
-			}
+			while ((itr_cnt--) && ((result = _mmcamcorder_capture_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE))
+				_mmcam_dbg_warn("Can't stop capturing.(%x)", result);
 
 			break;
 		}
@@ -3849,6 +3788,7 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
 			while ((itr_cnt--) && ((result = _mmcamcorder_commit((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
 				_mmcam_dbg_warn("Can't commit.(%x)", result);
 			}
+
 			break;
 		}
 		case MM_CAMCORDER_STATE_PREPARE:
@@ -3858,6 +3798,7 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
 			while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
 				_mmcam_dbg_warn("Can't stop preview.(%x)", result);
 			}
+
 			break;
 		}
 		case MM_CAMCORDER_STATE_READY:
@@ -3867,6 +3808,7 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
 			if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE) {
 				_mmcam_dbg_warn("Can't unrealize.(%x)", result);
 			}
+
 			break;
 		}
 		case MM_CAMCORDER_STATE_NULL:
@@ -3878,7 +3820,7 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
 		current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
 	}
 
-	_mmcam_dbg_warn( "Done." );
+	_mmcam_dbg_warn("Done.");
 
 	return;
 }
@@ -3929,10 +3871,10 @@ static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage *
 	if (message->src) {
 		msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
 		_mmcam_dbg_err("-Msg src : [%s] Domain : [%s]   Error : [%s]  Code : [%d] is tranlated to error code : [0x%x]",
-		               msg_src_element, g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
+			msg_src_element, g_quark_to_string(error->domain), error->message, error->code, msg.param.code);
 	} else {
 		_mmcam_dbg_err("Domain : [%s]   Error : [%s]  Code : [%d] is tranlated to error code : [0x%x]",
-		               g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
+			g_quark_to_string(error->domain), error->message, error->code, msg.param.code);
 	}
 
 #ifdef _MMCAMCORDER_SKIP_GST_FLOW_ERROR
@@ -3971,35 +3913,33 @@ static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, G
 	element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst);
 
 	if (GST_ELEMENT_CAST(message->src) == element) {
-		if (code == GST_CORE_ERROR_NEGOTIATION) {
+		if (code == GST_CORE_ERROR_NEGOTIATION)
 			return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
-		} else {
+		else
 			return MM_ERROR_CAMCORDER_ENCODER;
-		}
 	}
 
 	/* General */
-	switch (code)
-	{
-		case GST_CORE_ERROR_STATE_CHANGE:
-			return MM_ERROR_CAMCORDER_GST_STATECHANGE;
-		case GST_CORE_ERROR_NEGOTIATION:
-			return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
-		case GST_CORE_ERROR_MISSING_PLUGIN:
-		case GST_CORE_ERROR_SEEK:
-		case GST_CORE_ERROR_NOT_IMPLEMENTED:
-		case GST_CORE_ERROR_FAILED:
-		case GST_CORE_ERROR_TOO_LAZY:
-		case GST_CORE_ERROR_PAD:
-		case GST_CORE_ERROR_THREAD:
-		case GST_CORE_ERROR_EVENT:
-		case GST_CORE_ERROR_CAPS:
-		case GST_CORE_ERROR_TAG:
-		case GST_CORE_ERROR_CLOCK:
-		case GST_CORE_ERROR_DISABLED:
-		default:
-			return MM_ERROR_CAMCORDER_GST_CORE;
-		break;
+	switch (code) {
+	case GST_CORE_ERROR_STATE_CHANGE:
+		return MM_ERROR_CAMCORDER_GST_STATECHANGE;
+	case GST_CORE_ERROR_NEGOTIATION:
+		return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
+	case GST_CORE_ERROR_MISSING_PLUGIN:
+	case GST_CORE_ERROR_SEEK:
+	case GST_CORE_ERROR_NOT_IMPLEMENTED:
+	case GST_CORE_ERROR_FAILED:
+	case GST_CORE_ERROR_TOO_LAZY:
+	case GST_CORE_ERROR_PAD:
+	case GST_CORE_ERROR_THREAD:
+	case GST_CORE_ERROR_EVENT:
+	case GST_CORE_ERROR_CAPS:
+	case GST_CORE_ERROR_TAG:
+	case GST_CORE_ERROR_CLOCK:
+	case GST_CORE_ERROR_DISABLED:
+	default:
+		return MM_ERROR_CAMCORDER_GST_CORE;
+	break;
 	}
 }
 
@@ -4133,9 +4073,9 @@ static gint __mmcamcorder_gst_handle_stream_error(MMHandleType handle, int code,
 {
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
-	GstElement *element =NULL;
+	GstElement *element = NULL;
 
-	mmf_return_val_if_fail( hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
+	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
 	mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
@@ -4188,7 +4128,7 @@ static gint __mmcamcorder_gst_handle_stream_error(MMHandleType handle, int code,
 }
 
 
-static gboolean __mmcamcorder_handle_gst_warning (MMHandleType handle, GstMessage *message, GError *error)
+static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage *message, GError *error)
 {
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	gchar *debug = NULL;
@@ -4208,7 +4148,7 @@ static gboolean __mmcamcorder_handle_gst_warning (MMHandleType handle, GstMessag
 	} else if (error->domain == GST_RESOURCE_ERROR) {
 		_mmcam_dbg_warn("GST warning: GST_RESOURCE domain");
 		__mmcamcorder_gst_handle_resource_warning(handle, message, error);
-	} else if (error->domain == GST_STREAM_ERROR ) {
+	} else if (error->domain == GST_STREAM_ERROR) {
 		_mmcam_dbg_warn("GST warning: GST_STREAM domain");
 	} else {
 		_mmcam_dbg_warn("This error domain(%d) is not defined.", error->domain);
@@ -4219,7 +4159,7 @@ static gboolean __mmcamcorder_handle_gst_warning (MMHandleType handle, GstMessag
 		err = NULL;
 	}
 	if (debug != NULL) {
-		_mmcam_dbg_err ("Debug: %s", debug);
+		_mmcam_dbg_err("Debug: %s", debug);
 		g_free(debug);
 		debug = NULL;
 	}
@@ -4232,10 +4172,10 @@ static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMe
 {
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
-	GstElement *element =NULL;
+	GstElement *element = NULL;
 	gchar *msg_src_element;
 
-	mmf_return_val_if_fail( hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
+	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
 	mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
@@ -4249,7 +4189,7 @@ static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMe
 		if (error->code == GST_RESOURCE_ERROR_FAILED) {
 			msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
 			_mmcam_dbg_warn("-Msg src:[%s] Domain:[%s] Error:[%s]",
-			               msg_src_element, g_quark_to_string(error->domain), error->message);
+				msg_src_element, g_quark_to_string(error->domain), error->message);
 			return MM_ERROR_NONE;
 		}
 	}
@@ -4287,14 +4227,14 @@ int _mmcamcorder_get_video_caps(MMHandleType handle, char **caps)
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
 	_mmcam_dbg_warn("Entered ");
 	pad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "sink");
-	if(!pad) {
+	if (!pad) {
 		_mmcam_dbg_err("static pad is NULL");
 		return MM_ERROR_CAMCORDER_INVALID_STATE;
 	}
 
 	sink_caps = gst_pad_get_current_caps(pad);
-	gst_object_unref( pad );
-	if(!sink_caps) {
+	gst_object_unref(pad);
+	if (!sink_caps) {
 		_mmcam_dbg_err("fail to get caps");
 		return MM_ERROR_CAMCORDER_INVALID_STATE;
 	}
@@ -4307,17 +4247,16 @@ int _mmcamcorder_get_video_caps(MMHandleType handle, char **caps)
 }
 #ifdef _MMCAMCORDER_RM_SUPPORT
 rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
-        rm_device_request_s *info, void* cb_data)
+	rm_device_request_s *info, void* cb_data)
 {
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(cb_data);
 	int current_state = MM_CAMCORDER_STATE_NONE;
-    rm_cb_result cb_res = RM_CB_RESULT_OK;
+	rm_cb_result cb_res = RM_CB_RESULT_OK;
 
-    mmf_return_val_if_fail((MMHandleType)hcamcorder, RM_CB_RESULT_OK);
+	mmf_return_val_if_fail((MMHandleType)hcamcorder, RM_CB_RESULT_OK);
 
 	current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
-	if (current_state <= MM_CAMCORDER_STATE_NONE ||
-	    current_state >= MM_CAMCORDER_STATE_NUM) {
+	if (current_state <= MM_CAMCORDER_STATE_NONE || current_state >= MM_CAMCORDER_STATE_NUM) {
 		_mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state);
 	}
 
@@ -4344,6 +4283,6 @@ rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
 
 	_MMCAMCORDER_UNLOCK_ASM(hcamcorder);
 
-    return cb_res;
+	return cb_res;
 }
 #endif /* _MMCAMCORDER_RM_SUPPORT */
diff --git a/src/mm_camcorder_platform.c b/src/mm_camcorder_platform.c
index 5817538..b4c0117 100644
--- a/src/mm_camcorder_platform.c
+++ b/src/mm_camcorder_platform.c
@@ -22,7 +22,7 @@
 /*===========================================================================================
 |																							|
 |  INCLUDE FILES																			|
-|  																							|
+|																							|
 ========================================================================================== */
 #include "mm_camcorder_internal.h"
 #include "mm_camcorder_platform.h"
@@ -36,15 +36,15 @@
 |    LOCAL VARIABLE DEFINITIONS for internal								|
 ---------------------------------------------------------------------------*/
 
-
-// Rule 1. 1:1 match except NONE.
-// Rule 2. MSL should be Superset.
-// Rule 3. sensor value should not be same as _MMCAMCORDER_SENSOR_ENUM_NONE.
+/*
+ * Rule 1. 1:1 match except NONE.
+ * Rule 2. MSL should be Superset.
+ * Rule 3. sensor value should not be same as _MMCAMCORDER_SENSOR_ENUM_NONE.
+*/
 
 static int __enum_conv_whitebalance[MM_CAMCORDER_WHITE_BALANCE_NUM] ;
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_whitebalance =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_whitebalance = {
 	MM_CAMCORDER_WHITE_BALANCE_NUM,
 	__enum_conv_whitebalance,
 	CONFIGURE_CATEGORY_CTRL_EFFECT,
@@ -54,8 +54,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_whitebalance =
 
 static int __enum_conv_colortone[MM_CAMCORDER_COLOR_TONE_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_colortone =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_colortone = {
 	MM_CAMCORDER_COLOR_TONE_NUM,
 	__enum_conv_colortone,
 	CONFIGURE_CATEGORY_CTRL_EFFECT,
@@ -65,8 +64,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_colortone =
 
 static int __enum_conv_iso[MM_CAMCORDER_ISO_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_iso =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_iso = {
 	MM_CAMCORDER_ISO_NUM,
 	__enum_conv_iso,
 	CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
@@ -76,8 +74,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_iso =
 
 static int __enum_conv_prgrm[MM_CAMCORDER_SCENE_MODE_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_prgrm =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_prgrm = {
 	MM_CAMCORDER_SCENE_MODE_NUM,
 	__enum_conv_prgrm,
 	CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
@@ -87,8 +84,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_prgrm =
 
 static int __enum_conv_focus_mode[MM_CAMCORDER_FOCUS_MODE_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_mode =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_mode = {
 	MM_CAMCORDER_FOCUS_MODE_NUM,
 	__enum_conv_focus_mode,
 	CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
@@ -98,8 +94,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_mode =
 
 static int __enum_conv_focus_type[MM_CAMCORDER_AUTO_FOCUS_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_type =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_type = {
 	MM_CAMCORDER_AUTO_FOCUS_NUM,
 	__enum_conv_focus_type,
 	CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
@@ -109,8 +104,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_type =
 
 static int __enum_conv_ae_type[MM_CAMCORDER_AUTO_EXPOSURE_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_ae_type =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_ae_type = {
 	MM_CAMCORDER_AUTO_EXPOSURE_NUM,
 	__enum_conv_ae_type,
 	CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
@@ -120,8 +114,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_ae_type =
 
 static int __enum_conv_strobe_ctrl[MM_CAMCORDER_STROBE_CONTROL_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_ctrl =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_ctrl = {
 	MM_CAMCORDER_STROBE_CONTROL_NUM,
 	__enum_conv_strobe_ctrl,
 	CONFIGURE_CATEGORY_CTRL_STROBE,
@@ -131,8 +124,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_ctrl =
 
 static int __enum_conv_strobe_mode[MM_CAMCORDER_STROBE_MODE_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_mode =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_mode = {
 	MM_CAMCORDER_STROBE_MODE_NUM,
 	__enum_conv_strobe_mode,
 	CONFIGURE_CATEGORY_CTRL_STROBE,
@@ -142,8 +134,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_mode =
 
 static int __enum_conv_wdr_ctrl[MM_CAMCORDER_WDR_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_wdr_ctrl =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_wdr_ctrl = {
 	MM_CAMCORDER_WDR_NUM,
 	__enum_conv_wdr_ctrl,
 	CONFIGURE_CATEGORY_CTRL_EFFECT,
@@ -152,8 +143,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_wdr_ctrl =
 
 static int __enum_conv_flip_ctrl[MM_CAMCORDER_FLIP_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_flip_ctrl =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_flip_ctrl = {
 	MM_CAMCORDER_FLIP_NUM,
 	__enum_conv_flip_ctrl,
 	CONFIGURE_CATEGORY_CTRL_EFFECT,
@@ -162,8 +152,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_flip_ctrl =
 
 static int __enum_conv_rotation_ctrl[MM_CAMCORDER_ROTATION_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_rotation_ctrl =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_rotation_ctrl = {
 	MM_CAMCORDER_ROTATION_NUM,
 	__enum_conv_rotation_ctrl,
 	CONFIGURE_CATEGORY_CTRL_EFFECT,
@@ -173,8 +162,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_rotation_ctrl =
 
 static int __enum_conv_ahs[MM_CAMCORDER_AHS_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_ahs =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_ahs = {
 	MM_CAMCORDER_AHS_NUM,
 	__enum_conv_ahs,
 	CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
@@ -184,8 +172,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_ahs =
 
 static int __enum_conv_video_stabilization[MM_CAMCORDER_VIDEO_STABILIZATION_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_video_stabilization =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_video_stabilization = {
 	MM_CAMCORDER_VIDEO_STABILIZATION_NUM,
 	__enum_conv_video_stabilization,
 	CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
@@ -195,8 +182,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_video_stabilization =
 
 static int __enum_conv_hdr_capture[MM_CAMCORDER_HDR_CAPTURE_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_hdr_capture =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_hdr_capture = {
 	MM_CAMCORDER_HDR_CAPTURE_NUM,
 	__enum_conv_hdr_capture,
 	CONFIGURE_CATEGORY_CTRL_CAPTURE,
@@ -205,8 +191,7 @@ _MMCamcorderEnumConvert _mmcamcorder_enum_conv_hdr_capture =
 
 static int __enum_conv_detect_mode[MM_CAMCORDER_DETECT_MODE_NUM];
 
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_detect_mode =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_detect_mode = {
 	MM_CAMCORDER_DETECT_MODE_NUM,
 	__enum_conv_detect_mode,
 	CONFIGURE_CATEGORY_CTRL_DETECT,
@@ -674,57 +659,50 @@ static _MMCamcorderInfoConverting	g_caminfo_convert[CAMINFO_CONVERT_NUM] = {
 |    LOCAL FUNCTION PROTOTYPES:												|
 ---------------------------------------------------------------------------*/
 /* STATIC INTERNAL FUNCTION */
-static int  __mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default );
+static int  __mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default);
 
 /*===========================================================================================
 |																							|
 |  FUNCTION DEFINITIONS																		|
-|  																							|
+|																							|
 ========================================================================================== */
 /*---------------------------------------------------------------------------
 |    GLOBAL FUNCTION DEFINITIONS:											|
 ---------------------------------------------------------------------------*/
-//convert MSL value to sensor value
+/* convert MSL value to sensor value */
 int _mmcamcorder_convert_msl_to_sensor(MMHandleType handle, int attr_idx, int mslval)
 {
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderInfoConverting *info = NULL;
-	int i =0;
+	int i = 0;
 	int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
 
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
-	//_mmcam_dbg_log("attr_idx(%d), mslval(%d)", attr_idx, mslval);
+	/* _mmcam_dbg_log("attr_idx(%d), mslval(%d)", attr_idx, mslval); */
 
 	info = hcamcorder->caminfo_convert;
 
-	for (i = 0; i < size; i++)
-	{
-		if (info[i].attr_idx == attr_idx)
-		{
+	for (i = 0; i < size; i++) {
+		if (info[i].attr_idx == attr_idx) {
 			_MMCamcorderEnumConvert * enum_convert = NULL;
 			enum_convert = info[i].enum_convert;
 
-			if (enum_convert == NULL)
-			{
-				//_mmcam_dbg_log("enum_convert is NULL. Just return the original value.");
+			if (enum_convert == NULL) {
+				/* _mmcam_dbg_log("enum_convert is NULL. Just return the original value."); */
 				return mslval;
 			}
 
-			if (enum_convert->enum_arr == NULL)
-			{
+			if (enum_convert->enum_arr == NULL) {
 				_mmcam_dbg_warn("Unexpected error. Array pointer of enum_convert is NULL. Just return the original value.");
 				return mslval;
 			}
 
-			if( enum_convert->total_enum_num > mslval && mslval >= 0 )
-			{
-				//_mmcam_dbg_log("original value(%d) -> converted value(%d)", mslval, enum_convert->enum_arr[mslval]);
+			if (enum_convert->total_enum_num > mslval && mslval >= 0) {
+				/* _mmcam_dbg_log("original value(%d) -> converted value(%d)", mslval, enum_convert->enum_arr[mslval]); */
 				return enum_convert->enum_arr[mslval];
-			}
-			else
-			{
-				_mmcam_dbg_warn( "Input mslval[%d] is invalid(out of array[idx:%d,size:%d]), so can not convert. Just return the original value.", mslval, attr_idx, enum_convert->total_enum_num );
+			} else {
+				_mmcam_dbg_warn("Input mslval[%d] is invalid(out of array[idx:%d,size:%d]), so can not convert. Just return the original value.", mslval, attr_idx, enum_convert->total_enum_num);
 				return mslval;
 			}
 		}
@@ -747,7 +725,7 @@ int _mmcamcorder_get_fps_array_by_resolution(MMHandleType handle, int width, int
 
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 
-	//_mmcam_dbg_log("prev resolution w:%d, h:%d", width, height);
+	/* _mmcam_dbg_log("prev resolution w:%d, h:%d", width, height); */
 
 	infoW = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
 	if (infoW == NULL) {
@@ -768,9 +746,9 @@ int _mmcamcorder_get_fps_array_by_resolution(MMHandleType handle, int width, int
 	mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_WIDTH, infoW);
 	mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_HEIGHT, infoH);
 
-	for(i=0; i < infoW->int_array.count; i++) {
-		//_mmcam_dbg_log("width :%d, height : %d\n", infoW->int_array.array[i], infoH->int_array.array[i]);
-		if(infoW->int_array.array[i] == width && infoH->int_array.array[i] == height) {
+	for (i = 0; i < infoW->int_array.count; i++) {
+		/* _mmcam_dbg_log("width :%d, height : %d\n", infoW->int_array.array[i], infoH->int_array.array[i]); */
+		if (infoW->int_array.array[i] == width && infoH->int_array.array[i] == height) {
 			valid_check = true;
 			snprintf(nameFps, 10, "FPS%d", i);
 			_mmcam_dbg_log("nameFps : %s!!!", nameFps);
@@ -783,7 +761,7 @@ int _mmcamcorder_get_fps_array_by_resolution(MMHandleType handle, int width, int
 	free(infoH);
 	infoH = NULL;
 
-	if(!valid_check) {
+	if (!valid_check) {
 		_mmcam_dbg_err("FAILED : Can't find the valid resolution from attribute.");
 		return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
 	}
@@ -800,7 +778,7 @@ int _mmcamcorder_get_fps_array_by_resolution(MMHandleType handle, int width, int
 	return MM_ERROR_NONE;
 }
 
-//convert sensor value to MSL value
+/* convert sensor value to MSL value */
 int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int sensval)
 {
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
@@ -812,30 +790,24 @@ int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int se
 
 	info = hcamcorder->caminfo_convert;
 
-	for( i = 0 ; i < size ; i++ )
-	{
-		if( info[i].attr_idx == attr_idx )
-		{
+	for (i = 0 ; i < size ; i++) {
+		if (info[i].attr_idx == attr_idx) {
 			_MMCamcorderEnumConvert * enum_convert = NULL;
 			enum_convert = info[i].enum_convert;
 
-			if( enum_convert == NULL )
-			{
-				//_mmcam_dbg_log("enum_convert is NULL. Just return the original value.");
+			if (enum_convert == NULL) {
+				/* _mmcam_dbg_log("enum_convert is NULL. Just return the original value."); */
 				return sensval;
 			}
 
-			if( enum_convert->enum_arr == NULL )
-			{
+			if (enum_convert->enum_arr == NULL) {
 				_mmcam_dbg_warn("Unexpected error. Array pointer of enum_convert is NULL. Just return the original value.");
 				return sensval;
 			}
 
-			for( j = 0 ; j < enum_convert->total_enum_num ; j++ )
-			{
-				if( sensval == enum_convert->enum_arr[j] )
-				{
-					//_mmcam_dbg_log("original value(%d) -> converted value(%d)", sensval, j);
+			for (j = 0 ; j < enum_convert->total_enum_num ; j++) {
+				if (sensval == enum_convert->enum_arr[j]) {
+					/* _mmcam_dbg_log("original value(%d) -> converted value(%d)", sensval, j); */
 					return j;
 				}
 			}
@@ -851,16 +823,15 @@ int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int se
 }
 
 static int
-__mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default )
+__mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default)
 {
 	int i = 0;
 	int valid_count = 0;
 	int new_default = _MMCAMCORDER_SENSOR_ENUM_NONE;
 
 	for (i = 0; i < original_count; i++) {
-		if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE) {
+		if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE)
 			valid_count++;
-		}
 	}
 
 	if (valid_count > 0) {
@@ -880,15 +851,13 @@ __mmcamcorder_get_valid_array(int * original_array, int original_count, int ** v
 					}
 				}
 			}
-		}
-		else {
+		} else {
 			valid_count = 0;
 		}
 	}
 
-	if (new_default != _MMCAMCORDER_SENSOR_ENUM_NONE) {
+	if (new_default != _MMCAMCORDER_SENSOR_ENUM_NONE)
 		*valid_default = new_default;
-	}
 
 	return valid_count;
 }
@@ -955,176 +924,159 @@ int __mmcamcorder_set_info_to_attr(MMHandleType handle, _MMCamcorderInfoConverti
 
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
-	attrs = MMF_CAMCORDER_ATTRS (handle);
+	attrs = MMF_CAMCORDER_ATTRS(handle);
 	mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
 	camera_conf *conf_info = NULL;
 
-	for (i = 0; i < table_size ; i++ )
-	{
+	for (i = 0; i < table_size; i++) {
 		/*
-		_mmcam_dbg_log( "%d,%d,%d,%d,%s,%d",
-				info[i].type,
-				info[i].category,
-				info[i].attr_idx,
-				info[i].attr_idx_pair,
-				info[i].keyword,
-				info[i].conv_type );
+		_mmcam_dbg_log("%d,%d,%d,%d,%s,%d",
+			info[i].type,
+			info[i].category,
+			info[i].attr_idx,
+			info[i].attr_idx_pair,
+			info[i].keyword,
+			info[i].conv_type);
 		*/
 
-		if( info[i].type == CONFIGURE_TYPE_MAIN )
-		{
+		if (info[i].type == CONFIGURE_TYPE_MAIN) {
 			conf_info = hcamcorder->conf_main;
-			/*_mmcam_dbg_log( "MAIN configure [%s]", info[i].keyword );*/
-		}
-		else
-		{
+			/*_mmcam_dbg_log("MAIN configure [%s]", info[i].keyword);*/
+		} else {
 			conf_info = hcamcorder->conf_ctrl;
-			/*_mmcam_dbg_log( "CTRL configure [%s]", info[i].keyword );*/
+			/*_mmcam_dbg_log("CTRL configure [%s]", info[i].keyword);*/
 		}
 
-		switch(info[i].conv_type)
+		switch (info[i].conv_type) {
+		case MM_CAMCONVERT_TYPE_INT:
 		{
-			case MM_CAMCONVERT_TYPE_INT:
-			{
-				int ivalue = 0;
-
-				if (!_mmcamcorder_conf_get_value_int(handle, conf_info, info[i].category, info[i].keyword, &ivalue))
-				{
-					ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
-					break;		//skip to set
-				}
+			int ivalue = 0;
 
-				ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, ivalue);
-				break;
+			if (!_mmcamcorder_conf_get_value_int(handle, conf_info, info[i].category, info[i].keyword, &ivalue)) {
+				ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+				break;	/* skip to set */
 			}
-			case MM_CAMCONVERT_TYPE_INT_ARRAY:
-			{
-				int *iarray = NULL;
-				int iarray_size = 0;
-				int idefault = 0;
-				type_int_array *tarray = NULL;
-
-				if (!_mmcamcorder_conf_get_value_int_array( conf_info, info[i].category, info[i].keyword, &tarray ))
-				{
-					ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
-					break;		//skip to set
-				}
 
-				if( tarray )
-				{
-					idefault = tarray->default_value;
+			ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, ivalue);
+			break;
+		}
+		case MM_CAMCONVERT_TYPE_INT_ARRAY:
+		{
+			int *iarray = NULL;
+			int iarray_size = 0;
+			int idefault = 0;
+			type_int_array *tarray = NULL;
+
+			if (!_mmcamcorder_conf_get_value_int_array(conf_info, info[i].category, info[i].keyword, &tarray)) {
+				ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+				break;	/* skip to set */
+			}
 
-					if( info[i].enum_convert )
-					{
-						iarray_size = __mmcamcorder_get_valid_array(tarray->value, tarray->count, &iarray, &idefault);
-					}
-					else
-					{
-						iarray = tarray->value;
-						iarray_size = tarray->count;
-					}
+			if (tarray) {
+				idefault = tarray->default_value;
 
-					if( iarray_size > 0 )
-					{
-						/*
-						_mmcam_dbg_log("INT Array. attr idx=%d array=%p, size=%d, default=%d",
-						               info[i].attr_idx, iarray, iarray_size, idefault);
-						*/
+				if (info[i].enum_convert) {
+					iarray_size = __mmcamcorder_get_valid_array(tarray->value, tarray->count, &iarray, &idefault);
+				} else {
+					iarray = tarray->value;
+					iarray_size = tarray->count;
+				}
 
-						/* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
-						//mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
-						mmf_attrs_set_valid_array(attrs, info[i].attr_idx, iarray, iarray_size, idefault);
+				if (iarray_size > 0) {
+					/*
+					_mmcam_dbg_log("INT Array. attr idx=%d array=%p, size=%d, default=%d",
+						info[i].attr_idx, iarray, iarray_size, idefault);
+					*/
 
-						ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, idefault);
-					}
+					/* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+					/* mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY); */
+					mmf_attrs_set_valid_array(attrs, info[i].attr_idx, iarray, iarray_size, idefault);
+
+					ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, idefault);
 				}
+			}
 
-				if (iarray && iarray != tarray->value )
-					free(iarray);
+			if (iarray && iarray != tarray->value)
+				free(iarray);
 
-				break;
-			}
-			case MM_CAMCONVERT_TYPE_INT_RANGE:
-			{
-				type_int_range *irange = NULL;
-
-				if (!_mmcamcorder_conf_get_value_int_range(conf_info, info[i].category, info[i].keyword, &irange))
-				{
-					ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
-					break;		//skip to set
-				}
+			break;
+		}
+		case MM_CAMCONVERT_TYPE_INT_RANGE:
+		{
+			type_int_range *irange = NULL;
 
-				if( irange )
-				{
-					//_mmcam_dbg_log("INT Range. m:%d, s:%d, min=%d, max=%d", info[i].main_key, info[i].sub_key1, irange->min, irange->max);
-					/* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
-					//mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_RANGE);
-					mmf_attrs_set_valid_range(attrs, info[i].attr_idx, irange->min, irange->max, irange->default_value);
+			if (!_mmcamcorder_conf_get_value_int_range(conf_info, info[i].category, info[i].keyword, &irange)) {
+				ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+				break;	/* skip to set */
+			}
 
-					ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, irange->default_value);
-				}
+			if (irange) {
+				/* _mmcam_dbg_log("INT Range. m:%d, s:%d, min=%d, max=%d", info[i].main_key, info[i].sub_key1, irange->min, irange->max); */
+				/* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+				/* mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_RANGE); */
+				mmf_attrs_set_valid_range(attrs, info[i].attr_idx, irange->min, irange->max, irange->default_value);
 
-				break;
+				ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, irange->default_value);
 			}
-			case MM_CAMCONVERT_TYPE_STRING:
-			{
-				const char *cString = NULL;
-				unsigned int iString_len = 0;
-
-				if (!_mmcamcorder_conf_get_value_string(handle, conf_info, info[i].category, info[i].keyword, &cString ))
-				{
-					ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
-					break;		//skip to set
-				}
 
-				//_mmcam_dbg_log("String. m:%d, s:%d, cString=%s", info[i].main_key, info[i].sub_key1, cString);
-				//strlen makes a crash when null pointer is passed.
-				if (cString)
-					iString_len = strlen(cString);
-				else
-					iString_len = 0;
+			break;
+		}
+		case MM_CAMCONVERT_TYPE_STRING:
+		{
+			const char *cString = NULL;
+			unsigned int iString_len = 0;
 
-				ret = mm_attrs_set_string(attrs, info[i].attr_idx, cString, iString_len);
-				break;
+			if (!_mmcamcorder_conf_get_value_string(handle, conf_info, info[i].category, info[i].keyword, &cString)) {
+				ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+				break;	/* skip to set */
 			}
-			case MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY:
-			{
-				type_int_pair_array *pair_array = NULL;
 
-				/*_mmcam_dbg_log("INT PAIR Array. type:%d, attr_idx:%d, attr_idx_pair:%d", info[i].type, info[i].attr_idx, info[i].attr_idx_pair);*/
+			/* _mmcam_dbg_log("String. m:%d, s:%d, cString=%s", info[i].main_key, info[i].sub_key1, cString); */
+			/* strlen makes a crash when null pointer is passed. */
+			if (cString)
+				iString_len = strlen(cString);
+			else
+				iString_len = 0;
 
-				if (!_mmcamcorder_conf_get_value_int_pair_array(conf_info, info[i].category, info[i].keyword, &pair_array))
-				{
-					ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
-					break;		//skip to set
-				}
+			ret = mm_attrs_set_string(attrs, info[i].attr_idx, cString, iString_len);
+			break;
+		}
+		case MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY:
+		{
+			type_int_pair_array *pair_array = NULL;
 
-				if( pair_array && pair_array->count > 0 )
-				{
-					/* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
-					//mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
-					mmf_attrs_set_valid_array(attrs, info[i].attr_idx,
-					                          pair_array->value[0],
-					                          pair_array->count,
-					                          pair_array->default_value[0]);
-					/* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
-					//mmf_attrs_set_valid_type(attrs, info[i].attr_idx_pair, MM_ATTRS_VALID_TYPE_INT_ARRAY);
-					mmf_attrs_set_valid_array(attrs, info[i].attr_idx_pair,
-					                          pair_array->value[1],
-					                          pair_array->count,
-					                          pair_array->default_value[1]);
-
-					mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, pair_array->default_value[0]);
-					mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx_pair, pair_array->default_value[1]);
-				}
-				break;
+			/*_mmcam_dbg_log("INT PAIR Array. type:%d, attr_idx:%d, attr_idx_pair:%d", info[i].type, info[i].attr_idx, info[i].attr_idx_pair);*/
+
+			if (!_mmcamcorder_conf_get_value_int_pair_array(conf_info, info[i].category, info[i].keyword, &pair_array)) {
+				ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+				break;	/* skip to set */
 			}
 
-			case MM_CAMCONVERT_TYPE_USER:
-			default:
-				_mmcam_dbg_log("default : s:%d", info[i].attr_idx);
-				break;
+			if (pair_array && pair_array->count > 0) {
+				/* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+				/* mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY); */
+				mmf_attrs_set_valid_array(attrs, info[i].attr_idx,
+					pair_array->value[0],
+					pair_array->count,
+					pair_array->default_value[0]);
+				/* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+				/* mmf_attrs_set_valid_type(attrs, info[i].attr_idx_pair, MM_ATTRS_VALID_TYPE_INT_ARRAY); */
+				mmf_attrs_set_valid_array(attrs, info[i].attr_idx_pair,
+					pair_array->value[1],
+					pair_array->count,
+					pair_array->default_value[1]);
+
+				mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, pair_array->default_value[0]);
+				mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx_pair, pair_array->default_value[1]);
+			}
+			break;
+		}
+
+		case MM_CAMCONVERT_TYPE_USER:
+		default:
+			_mmcam_dbg_log("default : s:%d", info[i].attr_idx);
+			break;
 		}
 	}
 
@@ -1142,12 +1094,10 @@ int _mmcamcorder_set_converted_value(MMHandleType handle, _MMCamcorderEnumConver
 
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
-	_mmcamcorder_conf_get_value_int_array( hcamcorder->conf_ctrl, convert->category, convert->keyword, &array );
+	_mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl, convert->category, convert->keyword, &array);
 
-	if( array )
-	{
+	if (array)
 		convert->enum_arr = array->value;
-	}
 
 	return MM_ERROR_NONE;
 }
@@ -1246,21 +1196,18 @@ int _mmcamcorder_init_convert_table(MMHandleType handle)
 double _mmcamcorder_convert_volume(int mslVal)
 {
 	double newVal = -1;
-	switch (mslVal)
-	{
-		case 0:
-			newVal = 0;
-			break;
-		case 1:
-			newVal = 1;
-			break;
-		default:
-			_mmcam_dbg_warn("out of range");
-			break;
+	switch (mslVal) {
+	case 0:
+		newVal = 0;
+		break;
+	case 1:
+		newVal = 1;
+		break;
+	default:
+		_mmcam_dbg_warn("out of range");
+		break;
 	}
 
 	return newVal;
 }
 
-
-
diff --git a/src/mm_camcorder_resource.c b/src/mm_camcorder_resource.c
index 8634191..aea6271 100644
--- a/src/mm_camcorder_resource.c
+++ b/src/mm_camcorder_resource.c
@@ -26,8 +26,8 @@
 #define MRP_RESOURCE_TYPE_EXCLUSIVE FALSE
 
 const char* mm_camcorder_resource_str[MM_CAMCORDER_RESOURCE_MAX] = {
-    "camera",
-    "video_overlay"
+	"camera",
+	"video_overlay"
 };
 
 #define MMCAMCORDER_CHECK_RESOURCE_MANAGER_INSTANCE(x_camcorder_resource_manager) \
@@ -36,7 +36,7 @@ do { \
 		_mmcam_dbg_err("no resource manager instance"); \
 		return MM_ERROR_INVALID_ARGUMENT; \
 	} \
-} while(0);
+} while (0);
 
 #define MMCAMCORDER_CHECK_CONNECTION_RESOURCE_MANAGER(x_camcorder_resource_manager) \
 do { \
@@ -49,7 +49,7 @@ do { \
 			return MM_ERROR_RESOURCE_NOT_INITIALIZED; \
 		} \
 	} \
-} while(0);
+} while (0);
 
 static char *__mmcamcorder_resource_state_to_str(mrp_res_resource_state_t st)
 {
@@ -107,9 +107,8 @@ static void __mmcamcorder_resource_state_callback(mrp_res_context_t *context, mr
 			}
 			for (i = 0; i < resource_names->num_strings; i++) {
 				resource = mrp_res_get_resource_by_name(rset, resource_names->strings[i]);
-				if (resource) {
+				if (resource)
 					_mmcam_dbg_log(" - available resource: %s", resource->name);
-				}
 			}
 			mrp_res_free_string_array(resource_names);
 		}
@@ -223,8 +222,7 @@ static void __mmcamcorder_resource_release_cb(mrp_res_context_t *cx, const mrp_r
 		if (res == NULL) {
 			_mmcam_dbg_warn(" -- %s not present in resource set", mm_camcorder_resource_str[i]);
 		} else {
-			_mmcam_dbg_log(" -- resource name [%s] -> [%s]",
-				res->name, __mmcamcorder_resource_state_to_str(res->state));
+			_mmcam_dbg_log(" -- resource name [%s] -> [%s]", res->name, __mmcamcorder_resource_state_to_str(res->state));
 		}
 	}
 
@@ -254,9 +252,8 @@ static int __mmcamcorder_resource_create_resource_set(MMCamcorderResourceManager
 		return MM_ERROR_RESOURCE_INTERNAL;
 	}
 
-	if (!mrp_res_set_autorelease(TRUE, resource_manager->rset)) {
+	if (!mrp_res_set_autorelease(TRUE, resource_manager->rset))
 		_mmcam_dbg_warn(" - could not set autorelease flag!");
-	}
 
 	return MM_ERROR_NONE;
 }
@@ -265,9 +262,9 @@ static int __mmcamcorder_resource_include_resource(MMCamcorderResourceManager *r
 {
 	mrp_res_resource_t *resource = NULL;
 	resource = mrp_res_create_resource(resource_manager->rset,
-				resource_name,
-				MRP_RESOURCE_TYPE_MANDATORY,
-				MRP_RESOURCE_TYPE_EXCLUSIVE);
+		resource_name,
+		MRP_RESOURCE_TYPE_MANDATORY,
+		MRP_RESOURCE_TYPE_EXCLUSIVE);
 	if (resource == NULL) {
 		_mmcam_dbg_err(" - could not include resource[%s]", resource_name);
 		return MM_ERROR_RESOURCE_INTERNAL;
@@ -328,9 +325,9 @@ int _mmcamcorder_resource_manager_prepare(MMCamcorderResourceManager *resource_m
 	MMCAMCORDER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
 	MMCAMCORDER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager);
 
-	if (!resource_manager->rset) {
+	if (!resource_manager->rset)
 		ret = __mmcamcorder_resource_create_resource_set(resource_manager);
-	}
+
 	if (ret == MM_ERROR_NONE) {
 		ret = __mmcamcorder_resource_include_resource(resource_manager, mm_camcorder_resource_str[resource_type]);
 	} else {
diff --git a/src/mm_camcorder_sound.c b/src/mm_camcorder_sound.c
index 44e9dae..48abcf8 100644
--- a/src/mm_camcorder_sound.c
+++ b/src/mm_camcorder_sound.c
@@ -102,8 +102,8 @@ gboolean _mmcamcorder_sound_play(MMHandleType handle, const char *sample_name, g
 
 	/* check sound play enable */
 	mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
-	                            "capture-sound-enable", &sound_enable,
-	                            NULL);
+		"capture-sound-enable", &sound_enable,
+		NULL);
 	_mmcam_dbg_log("Capture sound enable %d", sound_enable);
 	if (!sound_enable) {
 		_mmcam_dbg_warn("capture sound disabled");
@@ -120,11 +120,10 @@ gboolean _mmcamcorder_sound_play(MMHandleType handle, const char *sample_name, g
 		return FALSE;
 	}
 
-	if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE02)) {
+	if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE02))
 		volume_gain = "shutter2";
-	} else if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_STOP)) {
+	else if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_STOP))
 		volume_gain = "camcording";
-	}
 
 	_mmcam_dbg_log("Play start - sample name [%s]", sample_name);
 
@@ -182,8 +181,8 @@ int _mmcamcorder_sound_solo_play(MMHandleType handle, const char *sample_name, g
 
 	/* check sound play enable */
 	mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
-	                            "capture-sound-enable", &sound_enable,
-	                            NULL);
+		"capture-sound-enable", &sound_enable,
+		NULL);
 	_mmcam_dbg_log("Capture sound enable %d", sound_enable);
 	if (!sound_enable) {
 		_mmcam_dbg_warn("capture sound disabled");
diff --git a/src/mm_camcorder_stillshot.c b/src/mm_camcorder_stillshot.c
index 648f3c1..0775a7b 100644
--- a/src/mm_camcorder_stillshot.c
+++ b/src/mm_camcorder_stillshot.c
@@ -38,8 +38,8 @@
 /*---------------------------------------------------------------------------------------
 |    GLOBAL VARIABLE DEFINITIONS for internal						|
 ---------------------------------------------------------------------------------------*/
-#define EXIF_SET_ERR( return_type,tag_id) \
-	_mmcam_dbg_err("error=%x,tag=%x",return_type,tag_id); \
+#define EXIF_SET_ERR(return_type, tag_id) \
+	_mmcam_dbg_err("error=%x,tag=%x", return_type, tag_id); \
 	if (return_type == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) { \
 		goto exit; \
 	}
@@ -102,16 +102,15 @@ int _mmcamcorder_create_stillshot_pipeline(MMHandleType handle)
 	_MMCAMCORDER_PIPELINE_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE, "capture_pipeline", err);
 
 	err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_IMAGE);
-	if (err != MM_ERROR_NONE) {
+	if (err != MM_ERROR_NONE)
 		return err;
-	}
 
 	/* add element and encodesink bin to encode main pipeline */
 	gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
-	                 sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst,
-	                 sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst,
-	                 sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
-	                 NULL);
+		sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst,
+		sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst,
+		sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
+		NULL);
 
 	/* Link each element : appsrc - capsfilter - encodesink bin */
 	srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, "src");
@@ -124,9 +123,9 @@ int _mmcamcorder_create_stillshot_pipeline(MMHandleType handle)
 
 	/* connect handoff signal to get capture data */
 	MMCAMCORDER_SIGNAL_CONNECT(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
-	                           _MMCAMCORDER_HANDLER_STILLSHOT, "handoff",
-	                           G_CALLBACK(__mmcamcorder_handoff_callback),
-	                           hcamcorder);
+		_MMCAMCORDER_HANDLER_STILLSHOT, "handoff",
+		G_CALLBACK(__mmcamcorder_handoff_callback),
+		hcamcorder);
 
 	return MM_ERROR_NONE;
 
@@ -150,9 +149,9 @@ int _mmcamcorder_connect_capture_signal(MMHandleType handle)
 	if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
 		_mmcam_dbg_warn("connect capture signal to _MMCAMCORDER_VIDEOSRC_SRC");
 		MMCAMCORDER_SIGNAL_CONNECT(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst,
-		                           _MMCAMCORDER_HANDLER_STILLSHOT, "still-capture",
-		                           G_CALLBACK(__mmcamcorder_image_capture_cb),
-		                           hcamcorder);
+			_MMCAMCORDER_HANDLER_STILLSHOT, "still-capture",
+			G_CALLBACK(__mmcamcorder_image_capture_cb),
+			hcamcorder);
 
 		return MM_ERROR_NONE;
 	} else {
@@ -255,9 +254,8 @@ void _mmcamcorder_destroy_video_capture_pipeline(MMHandleType handle)
 		/* ref element before remove it from pipeline */
 		gst_object_ref(sink_element);
 
-		if (!gst_bin_remove(GST_BIN(sc->element[_MMCAMCORDER_MAIN_PIPE].gst), sink_element)) {
+		if (!gst_bin_remove(GST_BIN(sc->element[_MMCAMCORDER_MAIN_PIPE].gst), sink_element))
 			_mmcam_dbg_warn("failed to remove sink element from pipeline");
-		}
 
 		/* set sink element pointer to attribute */
 		mm_attrs_get_index((MMHandleType)attrs, MMCAM_DISPLAY_REUSE_ELEMENT, &attr_index);
@@ -333,14 +331,14 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
 	}
 
 	_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
-	                                CONFIGURE_CATEGORY_MAIN_CAPTURE,
-	                                "UseCaptureMode",
-	                                &UseCaptureMode);
+		CONFIGURE_CATEGORY_MAIN_CAPTURE,
+		"UseCaptureMode",
+		&UseCaptureMode);
 
 	_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-	                              CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
-	                              "VideosrcElement",
-	                              &VideosrcElement);
+		CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+		"VideosrcElement",
+		&VideosrcElement);
 
 	_mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
 
@@ -351,18 +349,18 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
 	info->capturing = TRUE;
 
 	ret = mm_camcorder_get_attributes(handle, &err_name,
-	                            MMCAM_IMAGE_ENCODER, &image_encoder,
-	                            MMCAM_CAMERA_WIDTH, &width,
-	                            MMCAM_CAMERA_HEIGHT, &height,
-	                            MMCAM_CAMERA_FPS, &fps,
-	                            MMCAM_CAPTURE_FORMAT, &cap_format,
-	                            MMCAM_CAPTURE_WIDTH, &info->width,
-	                            MMCAM_CAPTURE_HEIGHT, &info->height,
-	                            MMCAM_CAPTURE_COUNT, &info->count,
-	                            MMCAM_CAPTURE_INTERVAL, &info->interval,
-	                            MMCAM_STROBE_MODE, &strobe_mode,
-	                            MMCAM_TAG_ORIENTATION, &tag_orientation,
-	                            NULL);
+		MMCAM_IMAGE_ENCODER, &image_encoder,
+		MMCAM_CAMERA_WIDTH, &width,
+		MMCAM_CAMERA_HEIGHT, &height,
+		MMCAM_CAMERA_FPS, &fps,
+		MMCAM_CAPTURE_FORMAT, &cap_format,
+		MMCAM_CAPTURE_WIDTH, &info->width,
+		MMCAM_CAPTURE_HEIGHT, &info->height,
+		MMCAM_CAPTURE_COUNT, &info->count,
+		MMCAM_CAPTURE_INTERVAL, &info->interval,
+		MMCAM_STROBE_MODE, &strobe_mode,
+		MMCAM_TAG_ORIENTATION, &tag_orientation,
+		NULL);
 	if (err_name) {
 		_mmcam_dbg_warn("get_attributes err %s, ret 0x%x", err_name, ret);
 		SAFE_FREE(err_name);
@@ -387,8 +385,8 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
 	}
 
 	_mmcam_dbg_log("preview(%dx%d,fmt:%d), capture(%dx%d,fmt:%d), count(%d), hdr mode(%d), interval (%d)",
-	               width, height, info->preview_format, info->width, info->height, cap_format,
-	               info->count, info->hdr_capture_mode, info->interval);
+		width, height, info->preview_format, info->width, info->height, cap_format,
+		info->count, info->hdr_capture_mode, info->interval);
 
 	/* check state */
 	if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
@@ -429,13 +427,13 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
 				_mmcam_dbg_log("Sensor JPEG Capture [is_modified_size:%d]", is_modified_size);
 			} else {
 				/* no need to encode internally if ITLV format */
-				if (info->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+				if (info->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY)
 					sc->internal_encode = TRUE;
-				}
+
 				cap_fourcc = _mmcamcorder_get_fourcc(info->preview_format, image_encoder, hcamcorder->use_zero_copy_format);
 
 				_mmcam_dbg_log("MSL JPEG Capture : capture fourcc %c%c%c%c",
-				               cap_fourcc, cap_fourcc>>8, cap_fourcc>>16, cap_fourcc>>24);
+					cap_fourcc, cap_fourcc>>8, cap_fourcc>>16, cap_fourcc>>24);
 			}
 		} else {
 			cap_fourcc = _mmcamcorder_get_fourcc(cap_format, MM_IMAGE_CODEC_INVALID, hcamcorder->use_zero_copy_format);
@@ -469,13 +467,11 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
 		}
 
 		if (UseCaptureMode) {
-			if (width != MMFCAMCORDER_HIGHQUALITY_WIDTH || height != MMFCAMCORDER_HIGHQUALITY_HEIGHT) {
+			if (width != MMFCAMCORDER_HIGHQUALITY_WIDTH || height != MMFCAMCORDER_HIGHQUALITY_HEIGHT)
 				need_change = 1;
-			}
 		} else {
-			if (width != info->width || height != info->height) {
+			if (width != info->width || height != info->height)
 				need_change = 1;
-			}
 		}
 
 		if (need_change) {
@@ -512,8 +508,8 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
 			}
 
 			mm_camcorder_get_attributes(handle, &err_name,
-			                            MMCAM_CAMERA_ROTATION, &rotation,
-			                            NULL);
+				MMCAM_CAMERA_ROTATION, &rotation,
+				NULL);
 			if (err_name) {
 				_mmcam_dbg_warn("get_attributes err %s", err_name);
 				SAFE_FREE(err_name);
@@ -550,8 +546,8 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
 		}
 
 		ret = mm_camcorder_get_attributes(handle, &err_name,
-		                                  MMCAM_IMAGE_ENCODER_QUALITY, &cap_jpeg_quality,
-		                                  NULL);
+			MMCAM_IMAGE_ENCODER_QUALITY, &cap_jpeg_quality,
+			NULL);
 		if (err_name) {
 			_mmcam_dbg_warn("get_attributes err %s, ret 0x%x", err_name, ret);
 			SAFE_FREE(err_name);
@@ -561,7 +557,7 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
 		MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_IENC].gst, "quality", cap_jpeg_quality);
 
 		/* set handoff signal as TRUE */
-		MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,"signal-handoffs", TRUE);
+		MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "signal-handoffs", TRUE);
 		MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
 
 		/* Prepare for the shutter sound when it's the bencbin mode capture */
@@ -597,9 +593,8 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
 	}
 
 cmd_done:
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		info->capturing = FALSE;
-	}
 
 	return ret;
 }
@@ -638,9 +633,9 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle)
 	info = sc->info_image;
 
 	_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-	                              CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
-	                              "VideosrcElement",
-	                              &VideosrcElement);
+		CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+		"VideosrcElement",
+		&VideosrcElement);
 
 	_mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
 
@@ -682,12 +677,12 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle)
 
 			/* This case is starting of preview */
 			ret = mm_camcorder_get_attributes(handle, &err_name,
-			                                  MMCAM_CAMERA_FPS_AUTO, &fps_auto,
-			                                  MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
-			                                  NULL);
+				MMCAM_CAMERA_FPS_AUTO, &fps_auto,
+				MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
+				NULL);
 			if (ret != MM_ERROR_NONE) {
 				_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret);
-				SAFE_FREE (err_name);
+				SAFE_FREE(err_name);
 			}
 
 			_mmcam_dbg_log("focus mode %d", focus_mode);
@@ -733,7 +728,7 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle)
 				}
 
 				while (current_framecount >= sc->kpi.video_framecount &&
-				       try_count++ < _MMCAMCORDER_CAPTURE_STOP_CHECK_COUNT) {
+					try_count++ < _MMCAMCORDER_CAPTURE_STOP_CHECK_COUNT) {
 					usleep(_MMCAMCORDER_CAPTURE_STOP_CHECK_INTERVAL);
 				}
 			}
@@ -744,12 +739,11 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle)
 			}
 
 			_mmcam_dbg_log("Wait Frame Done. count before[%d],after[%d], try_count[%d]",
-			               current_framecount, sc->kpi.video_framecount, try_count);
+						   current_framecount, sc->kpi.video_framecount, try_count);
 		} else {
 			ret = _mmcamcorder_remove_stillshot_pipeline(handle);
-			if (ret != MM_ERROR_NONE) {
+			if (ret != MM_ERROR_NONE)
 				goto cmd_error;
-			}
 
 			if (info->resolution_change) {
 				MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
@@ -766,17 +760,16 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle)
 				MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
 				MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
 
-				if (ret != MM_ERROR_NONE) {
+				if (ret != MM_ERROR_NONE)
 					goto cmd_error;
-				}
 
 				/* check if resolution need to rollback */
 				mm_camcorder_get_attributes(handle, &err_name,
-				                            MMCAM_CAMERA_WIDTH, &width,
-				                            MMCAM_CAMERA_HEIGHT, &height,
-				                            MMCAM_CAMERA_FPS, &fps,
-				                            MMCAM_CAMERA_ROTATION, &rotation,
-				                            NULL);
+					MMCAM_CAMERA_WIDTH, &width,
+					MMCAM_CAMERA_HEIGHT, &height,
+					MMCAM_CAMERA_FPS, &fps,
+					MMCAM_CAMERA_ROTATION, &rotation,
+					NULL);
 				if (err_name) {
 					_mmcam_dbg_warn("get_attributes err %s, ret 0x%x", err_name, ret);
 					SAFE_FREE(err_name);
@@ -791,16 +784,14 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle)
 				}
 
 				ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
-				if (ret != MM_ERROR_NONE) {
+				if (ret != MM_ERROR_NONE)
 					goto cmd_error;
-				}
 			}
 		}
 
 		/* sound finalize */
-		if (info->type == _MMCamcorder_MULTI_SHOT) {
+		if (info->type == _MMCamcorder_MULTI_SHOT)
 			_mmcamcorder_sound_finalize(handle);
-		}
 	} else {
 		if (info->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
 			MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "bitrate", H264_PREVIEW_BITRATE);
@@ -816,9 +807,8 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle)
 
 		traceEnd(TTRACE_TAG_CAMERA);
 
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			goto cmd_error;
-		}
 
 		/* get sound status/volume level and register changed_cb */
 		if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_OFF &&
@@ -862,8 +852,8 @@ int _mmcamcorder_image_cmd_preview_stop(MMHandleType handle)
 
 	/* check strobe and set OFF if PERMANENT mode */
 	mm_camcorder_get_attributes(handle, NULL,
-	                            MMCAM_STROBE_MODE, &strobe_mode,
-	                            NULL);
+		MMCAM_STROBE_MODE, &strobe_mode,
+		NULL);
 	if (strobe_mode == MM_CAMCORDER_STROBE_MODE_PERMANENT &&
 	    GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
 		_mmcam_dbg_log("current strobe mode is PERMANENT, set OFF");
@@ -885,8 +875,9 @@ int _mmcamcorder_image_cmd_preview_stop(MMHandleType handle)
 
 	pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
 
-	if(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst) {
-		_mmcam_dbg_log("pipeline is exist so need to remove pipeline and sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst=%p",sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst);
+	if (sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst) {
+		_mmcam_dbg_log("pipeline is exist so need to remove pipeline and sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst=%p",
+			sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst);
 		_mmcamcorder_remove_recorder_pipeline(handle);
 	}
 
@@ -969,7 +960,7 @@ int _mmcamcorder_video_capture_command(MMHandleType handle, int command)
 }
 
 
-void __mmcamcorder_init_stillshot_info (MMHandleType handle)
+void __mmcamcorder_init_stillshot_info(MMHandleType handle)
 {
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 	_MMCamcorderSubContext *sc = NULL;
@@ -984,7 +975,7 @@ void __mmcamcorder_init_stillshot_info (MMHandleType handle)
 
 	_mmcam_dbg_log("capture type[%d], capture send count[%d]", info->type, info->capture_send_count);
 
-	if (info->type ==_MMCamcorder_SINGLE_SHOT || info->capture_send_count == info->count) {
+	if (info->type == _MMCamcorder_SINGLE_SHOT || info->capture_send_count == info->count) {
 		info->capture_cur_count = 0;
 		info->capture_send_count = 0;
 		info->multi_shot_stop = TRUE;
@@ -1018,6 +1009,7 @@ int __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureD
 		} else {
 			_mmcam_dbg_log("data=%p, length=%d", original->data, original->length);
 		}
+
 		return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 	} else {
 		/* original is input/output param. save original values to local var. */
@@ -1029,17 +1021,17 @@ int __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureD
 		if (thumbnail) {
 			if (thumbnail->data && thumbnail->length > 0) {
 				_mmcam_dbg_log("thumbnail is added!thumbnail->data=%p thumbnail->width=%d ,thumbnail->height=%d",
-				               thumbnail->data, thumbnail->width, thumbnail->height);
+					thumbnail->data, thumbnail->width, thumbnail->height);
 
 				/* add thumbnail exif info */
 				ret = mm_exif_add_thumbnail_info(hcamcorder->exif_info,
-				                                 thumbnail->data,
-				                                 thumbnail->width,
-				                                 thumbnail->height,
-				                                 thumbnail->length);
+					thumbnail->data,
+					thumbnail->width,
+					thumbnail->height,
+					thumbnail->length);
 			} else {
 				_mmcam_dbg_err("Skip adding thumbnail (data=%p, length=%d)",
-				               thumbnail->data, thumbnail->length);
+					thumbnail->data, thumbnail->length);
 			}
 		}
 	} else {
@@ -1048,10 +1040,9 @@ int __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureD
 
 	if (ret == MM_ERROR_NONE) {
 		/* write jpeg with exif */
-		ret = mm_exif_write_exif_jpeg_to_memory(&original->data, &original->length ,hcamcorder->exif_info, data, datalen);
-		if (ret != MM_ERROR_NONE) {
-			_mmcam_dbg_err("mm_exif_write_exif_jpeg_to_memory error! [0x%x]",ret);
-		}
+		ret = mm_exif_write_exif_jpeg_to_memory(&original->data, &original->length, hcamcorder->exif_info, data, datalen);
+		if (ret != MM_ERROR_NONE)
+			_mmcam_dbg_err("mm_exif_write_exif_jpeg_to_memory error! [0x%x]", ret);
 	}
 
 	_mmcam_dbg_log("END ret 0x%x", ret);
@@ -1091,8 +1082,8 @@ void __mmcamcorder_get_capture_data_from_buffer(MMCamcorderCaptureDataType *capt
 	gst_buffer_unmap(gst_sample_get_buffer(sample), &mapinfo);
 
 	_mmcam_dbg_warn("buffer data[%p],size[%dx%d],length[%d],format[%d]",
-			capture_data->data, capture_data->width, capture_data->height,
-			capture_data->length, capture_data->format);
+		capture_data->data, capture_data->width, capture_data->height,
+		capture_data->length, capture_data->format);
 	return;
 
 GET_FAILED:
@@ -1118,11 +1109,10 @@ int __mmcamcorder_set_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType
 
 	/* if tag enable and doesn't provide exif, we make it */
 	_mmcam_dbg_log("Add exif information if existed(thumbnail[%p])", thumbnail);
-	if (thumbnail && thumbnail->data) {
+	if (thumbnail && thumbnail->data)
 		return __mmcamcorder_capture_save_exifinfo(handle, dest, thumbnail, provide_exif);
-	} else {
+	else
 		return __mmcamcorder_capture_save_exifinfo(handle, dest, NULL, provide_exif);
-	}
 }
 
 
@@ -1210,24 +1200,21 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 	_mmcam_dbg_err("START - current state %d", current_state);
 
 	/* check capture state */
-	if (info->type == _MMCamcorder_MULTI_SHOT && info->capture_send_count > 0) {
+	if (info->type == _MMCamcorder_MULTI_SHOT && info->capture_send_count > 0)
 		mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, "capture-break-cont-shot", &stop_cont_shot, NULL);
-	}
 
 	if (!info->capturing || stop_cont_shot) {
-		_mmcam_dbg_warn("stop command[%d] or not capturing state[%d]. skip this...",
-		                stop_cont_shot, info->capturing);
+		_mmcam_dbg_warn("stop command[%d] or not capturing state[%d]. skip this...", stop_cont_shot, info->capturing);
 
 		/*free GstBuffer*/
-		if (sample1) {
+		if (sample1)
 			gst_sample_unref(sample1);
-		}
-		if (sample2) {
+
+		if (sample2)
 			gst_sample_unref(sample2);
-		}
-		if (sample3) {
+
+		if (sample3)
 			gst_sample_unref(sample3);
-		}
 
 		return;
 	}
@@ -1284,22 +1271,22 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 		_mmcam_dbg_err("sample1[%p] is NULL or gst_buffer_map failed", sample1);
 		MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL);
 		goto error;
-	}else{
-		if ( (mapinfo1.data == NULL) && (mapinfo1.size == 0) ){
+	} else {
+		if ((mapinfo1.data == NULL) && (mapinfo1.size == 0)) {
 			_mmcam_dbg_err("mapinfo1 is wrong (%p, size %d)", mapinfo1.data, mapinfo1.size);
 			MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL);
 			gst_buffer_unmap(gst_sample_get_buffer(sample1), &mapinfo1);
 			goto error;
-		}else
+		} else {
 			__mmcamcorder_get_capture_data_from_buffer(&dest, pixtype_main, sample1);
+		}
 	}
 
-	if ( !sample2 || !gst_buffer_map(gst_sample_get_buffer(sample2), &mapinfo2, GST_MAP_READ) ) {
+	if (!sample2 || !gst_buffer_map(gst_sample_get_buffer(sample2), &mapinfo2, GST_MAP_READ))
 		_mmcam_dbg_log("sample2[%p] is NULL or gst_buffer_map failed. Not Error.", sample2);
-	}
-	if ( !sample3 || !gst_buffer_map(gst_sample_get_buffer(sample3), &mapinfo3, GST_MAP_READ)) {
+
+	if (!sample3 || !gst_buffer_map(gst_sample_get_buffer(sample3), &mapinfo3, GST_MAP_READ))
 		_mmcam_dbg_log("sample3[%p] is NULL or gst_buffer_map failed. Not Error.", sample3);
-	}
 
 	/* Screennail image buffer */
 	attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(hcamcorder);
@@ -1316,7 +1303,7 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 		ret = mmf_attribute_set_data(item_screennail, &scrnail, sizeof(scrnail));
 		_mmcam_dbg_log("Screennail set attribute data %p, size %d, ret %x", &scrnail, sizeof(scrnail), ret);
 	} else {
-		_mmcam_dbg_log("Sample3 has wrong pointer. Not Error. (sample3=%p)",sample3);
+		_mmcam_dbg_log("Sample3 has wrong pointer. Not Error. (sample3=%p)", sample3);
 		mmf_attribute_set_data(item_screennail, NULL, 0);
 	}
 
@@ -1331,7 +1318,7 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 
 	/* Thumbnail image buffer */
 	if (sample2 && mapinfo2.data && (mapinfo2.size != 0)) {
-		_mmcam_dbg_log("Thumbnail (buffer2=%p)",gst_sample_get_buffer(sample2));
+		_mmcam_dbg_log("Thumbnail (buffer2=%p)", gst_sample_get_buffer(sample2));
 		pixtype_thumb = _mmcamcorder_get_pixel_format(gst_sample_get_caps(sample2));
 		__mmcamcorder_get_capture_data_from_buffer(&thumb, pixtype_thumb, sample2);
 	} else {
@@ -1347,7 +1334,7 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 				char  height[10];
 				ExifEntry *entry = NULL;
 
-				exif_loader_write (l, dest.data, dest.length);
+				exif_loader_write(l, dest.data, dest.length);
 
 				/* Get a pointer to the EXIF data */
 				ed = exif_loader_get_data(l);
@@ -1357,19 +1344,19 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 				l = NULL;
 				if (ed) {
 					entry = exif_content_get_entry(ed->ifd[EXIF_IFD_1], EXIF_TAG_IMAGE_WIDTH);
-					if (entry != NULL) {
-						exif_entry_get_value(entry,width,10);
-					}
+					if (entry != NULL)
+						exif_entry_get_value(entry, width, 10);
+
 					entry = NULL;
 					entry = exif_content_get_entry(ed->ifd[EXIF_IFD_1], EXIF_TAG_IMAGE_LENGTH);
-					if (entry != NULL) {
-						exif_entry_get_value(entry,height , 10);
-					}
+					if (entry != NULL)
+						exif_entry_get_value(entry, height, 10);
+
 					entry = NULL;
 					/* Make sure the image had a thumbnail before trying to write it */
 					if (ed->data && ed->size) {
 						thumb.data = malloc(ed->size);
-						memcpy(thumb.data,ed->data,ed->size);
+						memcpy(thumb.data, ed->data, ed->size);
 						thumb.length = ed->size;
 						thumb.format = MM_PIXEL_FORMAT_ENCODED;
 						thumb.width = atoi(width);
@@ -1411,12 +1398,11 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 				/* calculate thumbnail size */
 				thumb_width = THUMBNAIL_WIDTH;
 				thumb_height = (thumb_width * encode_src.height) / encode_src.width;
-				if (thumb_height % 2 != 0) {
+				if (thumb_height % 2 != 0)
 					thumb_height += 1;
-				}
 
 				_mmcam_dbg_log("need to resize : thumbnail size %dx%d, format %d",
-				               thumb_width, thumb_height, encode_src.format);
+					thumb_width, thumb_height, encode_src.format);
 
 				if ((encode_src.format == MM_PIXEL_FORMAT_UYVY ||
 				     encode_src.format == MM_PIXEL_FORMAT_YUYV) &&
@@ -1450,8 +1436,7 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 					encode_src.format, thumb_length, THUMBNAIL_JPEG_QUALITY,
 					(void **)&internal_thumb_data, &internal_thumb_length);
 				if (ret) {
-					_mmcam_dbg_log("encode THUMBNAIL done - data %p, length %d",
-					               internal_thumb_data, internal_thumb_length);
+					_mmcam_dbg_log("encode THUMBNAIL done - data %p, length %d", internal_thumb_data, internal_thumb_length);
 
 					thumb.data = internal_thumb_data;
 					thumb.length = internal_thumb_length;
@@ -1472,7 +1457,7 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 				_mmcam_dbg_warn("thumb_raw_data is NULL");
 			}
 		} else {
-			// no raw data src for thumbnail
+			/* no raw data src for thumbnail */
 			_mmcam_dbg_log("no need to encode thumbnail");
 		}
 	}
@@ -1480,8 +1465,8 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 	/* Encode JPEG */
 	if (sc->internal_encode && pixtype_main != MM_PIXEL_FORMAT_ENCODED) {
 		mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
-		                            MMCAM_IMAGE_ENCODER_QUALITY, &capture_quality,
-		                            NULL);
+			MMCAM_IMAGE_ENCODER_QUALITY, &capture_quality,
+			NULL);
 		_mmcam_dbg_log("Start Internal Encode - capture_quality %d", capture_quality);
 
 		ret = _mmcamcorder_encode_jpeg(mapinfo1.data, dest.width, dest.height,
@@ -1504,9 +1489,9 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 	}
 
 	/* create EXIF info */
-	if(!provide_exif){ // make new exif
+	if (!provide_exif) {	/* make new exif */
 		ret = mm_exif_create_exif_info(&(hcamcorder->exif_info));
-	} else { // load from jpeg buffer dest.data
+	} else {	/* load from jpeg buffer dest.data */
 		ret = mm_exif_load_exif_info(&(hcamcorder->exif_info), dest.data, dest.length);
 		if (ret != MM_ERROR_NONE) {
 			_mmcam_dbg_err("Failed to load exif_info [%x], try to create EXIF", ret);
@@ -1518,7 +1503,7 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 		_mmcam_dbg_err("Failed to create exif_info [%x], but keep going...", ret);
 	} else {
 		/* add basic exif info */
-		if(!provide_exif) {
+		if (!provide_exif) {
 			_mmcam_dbg_log("add basic exif info");
 			ret = __mmcamcorder_set_exif_basic_info((MMHandleType)hcamcorder, dest.width, dest.height);
 		} else {
@@ -1558,11 +1543,11 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 	mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, MMCAM_TAG_ENABLE, &tag_enable, NULL);
 
 	/* Set extra data for JPEG if tag enabled and doesn't provide EXIF */
-	if (dest.format == MM_PIXEL_FORMAT_ENCODED){
+	if (dest.format == MM_PIXEL_FORMAT_ENCODED) {
 		if (tag_enable) {
 			mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
-			                            MMCAM_IMAGE_ENCODER, &codectype,
-			                            NULL);
+				MMCAM_IMAGE_ENCODER, &codectype,
+				NULL);
 			_mmcam_dbg_log("codectype %d", codectype);
 
 			switch (codectype) {
@@ -1589,11 +1574,11 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
 
 	if (hcamcorder->vcapture_cb) {
 		_mmcam_dbg_log("APPLICATION CALLBACK START");
-		if (thumb.data) {
+		if (thumb.data)
 			ret = hcamcorder->vcapture_cb(&dest, &thumb, hcamcorder->vcapture_cb_param);
-		} else {
+		else
 			ret = hcamcorder->vcapture_cb(&dest, NULL, hcamcorder->vcapture_cb_param);
-		}
+
 		_mmcam_dbg_log("APPLICATION CALLBACK END");
 	} else {
 		_mmcam_dbg_err("Capture callback is NULL.");
@@ -1622,9 +1607,8 @@ err_release_exif:
 	}
 
 	/* Release jpeg data */
-	if (pixtype_main == MM_PIXEL_FORMAT_ENCODED) {
+	if (pixtype_main == MM_PIXEL_FORMAT_ENCODED)
 		__mmcamcorder_release_jpeg_data((MMHandleType)hcamcorder, &dest, tag_enable, provide_exif);
-	}
 
 error:
 	/* Check end condition and set proper value */
@@ -1634,11 +1618,11 @@ error:
 	}
 
 	/* release internal allocated data */
-	if (sc->internal_encode) {
+	if (sc->internal_encode)
 		compare_data = internal_main_data;
-	} else {
+	else
 		compare_data = mapinfo1.data;
-	}
+
 	if (dest.data && compare_data &&
 	    dest.data != compare_data) {
 		_mmcam_dbg_log("release internal allocated data %p", dest.data);
@@ -1749,17 +1733,15 @@ static ExifData *__mmcamcorder_update_exif_orientation(MMHandleType handle, Exif
 	int ret = MM_ERROR_NONE;
 
 	mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_ORIENTATION, &value, NULL);
-	_mmcam_dbg_log("get orientation [%d]",value);
-	if (value == 0) {
+	_mmcam_dbg_log("get orientation [%d]", value);
+	if (value == 0)
 		value = MM_EXIF_ORIENTATION;
-	}
 
 	exif_set_short((unsigned char *)&eshort, exif_data_get_byte_order(ed), value);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_ORIENTATION,
-	                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort);
-	if (ret != MM_ERROR_NONE) {
+		EXIF_FORMAT_SHORT, 1, (const char *)&eshort);
+	if (ret != MM_ERROR_NONE)
 		EXIF_SET_ERR(ret, EXIF_TAG_MAKER_NOTE);
-	}
 
 exit:
 	return ed;
@@ -1774,11 +1756,10 @@ static ExifData *__mmcamcorder_update_exif_make(MMHandleType handle, ExifData *e
 	if (make) {
 		_mmcam_dbg_log("maker [%s]", make);
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_MAKE,
-		                            EXIF_FORMAT_ASCII, strlen(make)+1, (const char *)make);
+			EXIF_FORMAT_ASCII, strlen(make)+1, (const char *)make);
 		free(make);
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			EXIF_SET_ERR(ret, EXIF_TAG_MAKE);
-		}
 	} else {
 		ret = MM_ERROR_CAMCORDER_LOW_MEMORY;
 		EXIF_SET_ERR(ret, EXIF_TAG_MAKE);
@@ -1801,7 +1782,7 @@ static ExifData *__mmcamcorder_update_exif_software(MMHandleType handle, ExifDat
 
 	if (hcamcorder->software_version) {
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_SOFTWARE, EXIF_FORMAT_ASCII,
-		                            strlen(hcamcorder->software_version)+1, (const char *)hcamcorder->software_version);
+			strlen(hcamcorder->software_version)+1, (const char *)hcamcorder->software_version);
 		if (ret != MM_ERROR_NONE) {
 			_mmcam_dbg_err("set software_version[%s] failed", hcamcorder->software_version);
 		} else {
@@ -1827,7 +1808,7 @@ static ExifData *__mmcamcorder_update_exif_model(MMHandleType handle, ExifData *
 
 	if (hcamcorder->model_name) {
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_MODEL, EXIF_FORMAT_ASCII,
-		                            strlen(hcamcorder->model_name)+1, (const char *)hcamcorder->model_name);
+			strlen(hcamcorder->model_name)+1, (const char *)hcamcorder->model_name);
 		if (ret != MM_ERROR_NONE) {
 			_mmcam_dbg_err("set model name[%s] failed", hcamcorder->model_name);
 		} else {
@@ -1851,20 +1832,19 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed
 
 	ret = mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_GPS_ENABLE, &gps_enable, NULL);
 	if (ret == MM_ERROR_NONE && gps_enable) {
-		ExifByte GpsVersion[4]={2,2,0,0};
+		ExifByte GpsVersion[4] = {2, 2, 0, 0};
 
 		_mmcam_dbg_log("Tag for GPS is ENABLED.");
 
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_VERSION_ID,
-		                            EXIF_FORMAT_BYTE, 4, (const char *)&GpsVersion);
-		if (ret != MM_ERROR_NONE) {
+			EXIF_FORMAT_BYTE, 4, (const char *)&GpsVersion);
+		if (ret != MM_ERROR_NONE)
 			EXIF_SET_ERR(ret, EXIF_TAG_GPS_VERSION_ID);
-		}
 
 		ret = mm_camcorder_get_attributes(handle, &err_name,
-		                                  MMCAM_TAG_LATITUDE, &latitude,
-		                                  MMCAM_TAG_LONGITUDE, &longitude,
-		                                  MMCAM_TAG_ALTITUDE, &altitude, NULL);
+			MMCAM_TAG_LATITUDE, &latitude,
+			MMCAM_TAG_LONGITUDE, &longitude,
+			MMCAM_TAG_ALTITUDE, &altitude, NULL);
 		if (ret != MM_ERROR_NONE) {
 			_mmcam_dbg_err("failed to get gps info [%x][%s]", ret, err_name);
 			SAFE_FREE(err_name);
@@ -1881,22 +1861,23 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed
 
 			if (latitude < 0) {
 				ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE_REF,
-				                            EXIF_FORMAT_ASCII, 2, "S");
+					EXIF_FORMAT_ASCII, 2, "S");
 				if (ret != MM_ERROR_NONE) {
 					EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE_REF);
 				}
+
 				latitude = -latitude;
 			} else if (latitude > 0) {
 				ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE_REF,
-				                            EXIF_FORMAT_ASCII, 2, "N");
+					EXIF_FORMAT_ASCII, 2, "N");
 				if (ret != MM_ERROR_NONE) {
 					EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE_REF);
 				}
 			}
 
 			deg = (unsigned int)(latitude);
-			min = (unsigned int)((latitude-deg)*60);
-			sec = (unsigned int)(((latitude-deg)*3600)-min*60);
+			min = (unsigned int)((latitude-deg) * 60);
+			sec = (unsigned int)(((latitude-deg) * 3600) - min * 60);
 
 			_mmcam_dbg_log("f_latitude deg[%d], min[%d], sec[%d]", deg, min, sec);
 			b = malloc(3 * sizeof(ExifRational));
@@ -1905,16 +1886,15 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed
 				rData.denominator = 1;
 				exif_set_rational(b, exif_data_get_byte_order(ed), rData);
 				rData.numerator = min;
-				exif_set_rational(b+8, exif_data_get_byte_order(ed), rData);
+				exif_set_rational(b + 8, exif_data_get_byte_order(ed), rData);
 				rData.numerator = sec;
-				exif_set_rational(b+16, exif_data_get_byte_order(ed), rData);
+				exif_set_rational(b + 16, exif_data_get_byte_order(ed), rData);
 
 				ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE,
-				                            EXIF_FORMAT_RATIONAL, 3, (const char *)b);
+					EXIF_FORMAT_RATIONAL, 3, (const char *)b);
 				free(b);
-				if (ret != MM_ERROR_NONE) {
+				if (ret != MM_ERROR_NONE)
 					EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE);
-				}
 			} else {
 				_mmcam_dbg_warn("malloc failed");
 			}
@@ -1930,22 +1910,23 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed
 
 			if (longitude < 0) {
 				ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE_REF,
-				                            EXIF_FORMAT_ASCII, 2, "W");
+					EXIF_FORMAT_ASCII, 2, "W");
 				if (ret != MM_ERROR_NONE) {
 					EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE_REF);
 				}
+
 				longitude = -longitude;
 			} else if (longitude > 0) {
 				ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE_REF,
-				                            EXIF_FORMAT_ASCII, 2, "E");
+					EXIF_FORMAT_ASCII, 2, "E");
 				if (ret != MM_ERROR_NONE) {
 					EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE_REF);
 				}
 			}
 
 			deg = (unsigned int)(longitude);
-			min = (unsigned int)((longitude-deg)*60);
-			sec = (unsigned int)(((longitude-deg)*3600)-min*60);
+			min = (unsigned int)((longitude-deg) * 60);
+			sec = (unsigned int)(((longitude-deg) * 3600) - min * 60);
 
 			_mmcam_dbg_log("longitude deg[%d], min[%d], sec[%d]", deg, min, sec);
 			b = malloc(3 * sizeof(ExifRational));
@@ -1958,11 +1939,10 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed
 				rData.numerator = sec;
 				exif_set_rational(b+16, exif_data_get_byte_order(ed), rData);
 				ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE,
-				                            EXIF_FORMAT_RATIONAL, 3, (const char *)b);
+					EXIF_FORMAT_RATIONAL, 3, (const char *)b);
 				free(b);
-				if (ret != MM_ERROR_NONE) {
+				if (ret != MM_ERROR_NONE)
 					EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE);
-				}
 			} else {
 				_mmcam_dbg_warn("malloc failed");
 			}
@@ -1981,7 +1961,7 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed
 				}
 
 				ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_ALTITUDE_REF,
-				                            EXIF_FORMAT_BYTE, 1, (const char *)&alt_ref);
+					EXIF_FORMAT_BYTE, 1, (const char *)&alt_ref);
 				if (ret != MM_ERROR_NONE) {
 					_mmcam_dbg_err("error [%x], tag [%x]", ret, EXIF_TAG_GPS_ALTITUDE_REF);
 					if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) {
@@ -1995,11 +1975,10 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed
 				rData.denominator = 100;
 				exif_set_rational(b, exif_data_get_byte_order(ed), rData);
 				ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_ALTITUDE,
-				                            EXIF_FORMAT_RATIONAL, 1, (const char *)b);
+					EXIF_FORMAT_RATIONAL, 1, (const char *)b);
 				free(b);
-				if (ret != MM_ERROR_NONE) {
+				if (ret != MM_ERROR_NONE)
 					EXIF_SET_ERR(ret, EXIF_TAG_GPS_ALTITUDE);
-				}
 			} else {
 				_mmcam_dbg_warn("malloc failed");
 			}
@@ -2036,13 +2015,12 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed
 					exif_set_rational(b + 16, exif_data_get_byte_order(ed), rData);
 
 					ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_TIME_STAMP,
-					                            EXIF_FORMAT_RATIONAL, 3, (const char *)b);
+						EXIF_FORMAT_RATIONAL, 3, (const char *)b);
 					free(b);
-					if (ret != MM_ERROR_NONE) {
+					if (ret != MM_ERROR_NONE)
 						EXIF_SET_ERR(ret, EXIF_TAG_GPS_TIME_STAMP);
-					}
 				} else {
-					_mmcam_dbg_warn( "malloc failed." );
+					_mmcam_dbg_warn("malloc failed.");
 				}
 			}
 		}
@@ -2058,10 +2036,9 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed
 
 				/* cause it should include NULL char */
 				ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_DATE_STAMP,
-				                            EXIF_FORMAT_ASCII, date_stamp_len + 1, (const char *)date_stamp);
-				if (ret != MM_ERROR_NONE) {
+					EXIF_FORMAT_ASCII, date_stamp_len + 1, (const char *)date_stamp);
+				if (ret != MM_ERROR_NONE)
 					EXIF_SET_ERR(ret, EXIF_TAG_GPS_DATE_STAMP);
-				}
 			}
 		}
 
@@ -2075,14 +2052,14 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed
 				_mmcam_dbg_log("Processing method [%s]", processing_method);
 
 				ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_PROCESSING_METHOD,
-				                            EXIF_FORMAT_UNDEFINED, processing_method_len, (const char *)processing_method);
+					EXIF_FORMAT_UNDEFINED, processing_method_len, (const char *)processing_method);
 				if (ret != MM_ERROR_NONE) {
 					EXIF_SET_ERR(ret, EXIF_TAG_GPS_PROCESSING_METHOD);
 				}
 			}
 		}
 	} else {
-		_mmcam_dbg_log( "Tag for GPS is DISABLED." );
+		_mmcam_dbg_log("Tag for GPS is DISABLED.");
 	}
 
 exit:
@@ -2101,7 +2078,7 @@ int __mmcamcorder_update_exif_info(MMHandleType handle, void* imagedata, int img
 	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
 	ed = exif_data_new_from_data(imagedata, imgln);
-	//ed = mm_exif_get_exif_from_info(hcamcorder->exif_info);
+	/*ed = mm_exif_get_exif_from_info(hcamcorder->exif_info);*/
 
 	if (ed == NULL) {
 		_mmcam_dbg_err("get exif data error!!");
@@ -2177,43 +2154,42 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	/*0. EXIF_TAG_EXIF_VERSION */
 	ExifVersion = MM_EXIF_VERSION;
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXIF_VERSION,
-	                            EXIF_FORMAT_UNDEFINED, 4, (const char *)&ExifVersion);
-	if (ret != MM_ERROR_NONE) {
+		EXIF_FORMAT_UNDEFINED, 4, (const char *)&ExifVersion);
+	if (ret != MM_ERROR_NONE)
 		EXIF_SET_ERR(ret, EXIF_TAG_EXIF_VERSION);
-	}
 
 	/*1. EXIF_TAG_IMAGE_WIDTH */ /*EXIF_TAG_PIXEL_X_DIMENSION*/
 	value = image_width;
 
 	exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), value);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_WIDTH,
-	                            EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]);
-	if (ret != MM_ERROR_NONE) {
+		EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]);
+	if (ret != MM_ERROR_NONE)
 		EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_WIDTH);
-	}
 
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_X_DIMENSION,
-	                            EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
-	if (ret != MM_ERROR_NONE) {
+		EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
+	if (ret != MM_ERROR_NONE)
 		EXIF_SET_ERR(ret, EXIF_TAG_PIXEL_X_DIMENSION);
-	}
+
 	_mmcam_dbg_log("width[%d]", value);
 
 	/*2. EXIF_TAG_IMAGE_LENGTH*/ /*EXIF_TAG_PIXEL_Y_DIMENSION*/
 	value = image_height;
 
-	exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order (ed), value);
+	exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), value);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_LENGTH,
-	                            EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]);
+		EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]);
 	if (ret != MM_ERROR_NONE) {
 		EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_LENGTH);
 	}
 
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_Y_DIMENSION,
-	                            EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
+		EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
 	if (ret != MM_ERROR_NONE) {
 		EXIF_SET_ERR(ret, EXIF_TAG_PIXEL_Y_DIMENSION);
 	}
+
 	_mmcam_dbg_log("height[%d]", value);
 
 	/*4. EXIF_TAG_DATE_TIME */
@@ -2240,30 +2216,30 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		localtime_r(&t, &tm);
 
 		snprintf((char *)b, 20, "%04i:%02i:%02i %02i:%02i:%02i",
-		         tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
-		         tm.tm_hour, tm.tm_min, tm.tm_sec);
+			tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+			tm.tm_hour, tm.tm_min, tm.tm_sec);
 
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_DATE_TIME, EXIF_FORMAT_ASCII, 20, (const char *)b);
 		if (ret != MM_ERROR_NONE) {
-			if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) {
+			if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY)
 				free(b);
-			}
+
 			EXIF_SET_ERR(ret, EXIF_TAG_DATE_TIME);
 		}
 
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_ORIGINAL, EXIF_FORMAT_ASCII, 20, (const char *)b);
 		if (ret != MM_ERROR_NONE) {
-			if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) {
+			if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY)
 				free(b);
-			}
+
 			EXIF_SET_ERR(ret, EXIF_TAG_DATE_TIME_ORIGINAL);
 		}
 
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_DIGITIZED, EXIF_FORMAT_ASCII, 20, (const char *)b);
 		if (ret != MM_ERROR_NONE) {
-			if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) {
+			if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY)
 				free(b);
-			}
+
 			EXIF_SET_ERR(ret, EXIF_TAG_DATE_TIME_DIGITIZED);
 		}
 
@@ -2288,13 +2264,12 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 
 		if (description) {
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_DESCRIPTION,
-			                            EXIF_FORMAT_ASCII, strlen(description), (const char *)description);
+				EXIF_FORMAT_ASCII, strlen(description), (const char *)description);
 			free(description);
 			str_value = NULL;
 			str_val_len = 0;
-			if (ret != MM_ERROR_NONE) {
+			if (ret != MM_ERROR_NONE)
 				EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_DESCRIPTION);
-			}
 		} else {
 			_mmcam_dbg_err("strdup failed for [%s]", str_value);
 		}
@@ -2310,10 +2285,10 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		char software[50] = {0,};
 		unsigned int len = 0;
 
-		len = snprintf(software, sizeof(software), "%x.%x ", avsys_exif_info.software_used>>8,(avsys_exif_info.software_used & 0xff));
+		len = snprintf(software, sizeof(software), "%x.%x ", avsys_exif_info.software_used>>8, (avsys_exif_info.software_used & 0xff));
 		_mmcam_dbg_log("software [%s], len [%d]", software, len);
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_SOFTWARE,
-		                            EXIF_FORMAT_ASCII, len, (const char *)software);
+			EXIF_FORMAT_ASCII, len, (const char *)software);
 		if (ret != MM_ERROR_NONE) {
 			EXIF_SET_ERR(ret, EXIF_TAG_SOFTWARE);
 		}
@@ -2328,13 +2303,12 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	/*FIXME : get user comment from real user */
 	user_comment = strdup(MM_USER_COMMENT);
 	if (user_comment) {
-		_mmcam_dbg_log("user_comment=%s",user_comment);
+		_mmcam_dbg_log("user_comment=%s", user_comment);
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_USER_COMMENT,
-		                            EXIF_FORMAT_ASCII, strlen(user_comment), (const char *)user_comment);
+			EXIF_FORMAT_ASCII, strlen(user_comment), (const char *)user_comment);
 		free(user_comment);
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			EXIF_SET_ERR(ret, EXIF_TAG_USER_COMMENT);
-		}
 	} else {
 		ret = MM_ERROR_CAMCORDER_LOW_MEMORY;
 		EXIF_SET_ERR(ret, EXIF_TAG_USER_COMMENT);
@@ -2344,7 +2318,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	if (control != NULL) {
 		exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.colorspace);
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COLOR_SPACE,
-		                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+			EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 		if (ret != MM_ERROR_NONE) {
 			EXIF_SET_ERR(ret, EXIF_TAG_COLOR_SPACE);
 		}
@@ -2353,9 +2327,9 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	/*10. EXIF_TAG_COMPONENTS_CONFIGURATION */
 	if (control != NULL) {
 		config = avsys_exif_info.component_configuration;
-		_mmcam_dbg_log("EXIF_TAG_COMPONENTS_CONFIGURATION [%4x] ",config);
+		_mmcam_dbg_log("EXIF_TAG_COMPONENTS_CONFIGURATION [%4x] ", config);
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COMPONENTS_CONFIGURATION,
-		                            EXIF_FORMAT_UNDEFINED, 4, (const char *)&config);
+			EXIF_FORMAT_UNDEFINED, 4, (const char *)&config);
 		if (ret != MM_ERROR_NONE) {
 			EXIF_SET_ERR(ret, EXIF_TAG_COMPONENTS_CONFIGURATION);
 		}
@@ -2373,7 +2347,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		ExifRational rData;
 
 		_mmcam_dbg_log("EXIF_TAG_EXPOSURE_TIME numerator [%d], denominator [%d]",
-		               avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator);
+			avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator);
 
 		b = malloc(sizeof(ExifRational));
 		if (b) {
@@ -2382,7 +2356,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 
 			exif_set_rational(b, exif_data_get_byte_order(ed), rData);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_TIME,
-			                            EXIF_FORMAT_RATIONAL, 1, (const char *)b);
+				EXIF_FORMAT_RATIONAL, 1, (const char *)b);
 			free(b);
 			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_TIME);
@@ -2392,7 +2366,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		}
 	} else {
 		_mmcam_dbg_log("Skip set EXIF_TAG_EXPOSURE_TIME numerator [%d], denominator [%d]",
-		               avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator);
+			avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator);
 	}
 
 	/*15. EXIF_TAG_FNUMBER */
@@ -2401,7 +2375,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		ExifRational rData;
 
 		_mmcam_dbg_log("EXIF_TAG_FNUMBER numerator [%d], denominator [%d]",
-		               avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator);
+			avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator);
 
 		b = malloc(sizeof(ExifRational));
 		if (b) {
@@ -2409,17 +2383,17 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 			rData.denominator = avsys_exif_info.aperture_f_num_denominator;
 			exif_set_rational(b, exif_data_get_byte_order(ed), rData);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FNUMBER,
-			                            EXIF_FORMAT_RATIONAL, 1, (const char *)b);
+				EXIF_FORMAT_RATIONAL, 1, (const char *)b);
 			free(b);
-			if(ret != MM_ERROR_NONE) {
+			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_FNUMBER);
 			}
 		} else {
-			_mmcam_dbg_warn( "malloc failed." );
+			_mmcam_dbg_warn("malloc failed.");
 		}
 	} else {
 		_mmcam_dbg_log("Skip set EXIF_TAG_FNUMBER numerator [%d], denominator [%d]",
-		               avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator);
+			avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator);
 	}
 
 	/*16. EXIF_TAG_EXPOSURE_PROGRAM*/
@@ -2427,17 +2401,16 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	value = MM_EXPOSURE_PROGRAM;
 	exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_PROGRAM,
-	                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
-	if (ret != MM_ERROR_NONE) {
+		EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+	if (ret != MM_ERROR_NONE)
 		EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_PROGRAM);
-	}
 
 	/*17. EXIF_TAG_ISO_SPEED_RATINGS*/
 	if (avsys_exif_info.iso) {
 		_mmcam_dbg_log("EXIF_TAG_ISO_SPEED_RATINGS [%d]", avsys_exif_info.iso);
 		exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.iso);
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS,
-		                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+			EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 		if (ret != MM_ERROR_NONE) {
 			EXIF_SET_ERR(ret, EXIF_TAG_ISO_SPEED_RATINGS);
 		}
@@ -2449,7 +2422,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		ExifSRational rsData;
 
 		_mmcam_dbg_log("EXIF_TAG_SHUTTER_SPEED_VALUE numerator [%d], denominator [%d]",
-		               avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator);
+			avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator);
 
 		b = malloc(sizeof(ExifSRational));
 		if (b) {
@@ -2457,7 +2430,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 			rsData.denominator = avsys_exif_info.shutter_speed_denominator;
 			exif_set_srational(b, exif_data_get_byte_order(ed), rsData);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SHUTTER_SPEED_VALUE,
-			                            EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
+				EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
 			free(b);
 			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_SHUTTER_SPEED_VALUE);
@@ -2467,7 +2440,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		}
 	} else {
 		_mmcam_dbg_log("Skip set EXIF_TAG_SHUTTER_SPEED_VALUE numerator [%d], denominator [%d]",
-		               avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator);
+			avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator);
 	}
 
 	/*19. EXIF_TAG_APERTURE_VALUE*/
@@ -2483,9 +2456,9 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 			rData.denominator = 1;
 			exif_set_rational(b, exif_data_get_byte_order(ed), rData);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_APERTURE_VALUE,
-			                            EXIF_FORMAT_RATIONAL, 1, (const char *)b);
+				EXIF_FORMAT_RATIONAL, 1, (const char *)b);
 			free(b);
-			if(ret != MM_ERROR_NONE) {
+			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_APERTURE_VALUE);
 			}
 		} else {
@@ -2501,7 +2474,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		ExifSRational rsData;
 
 		_mmcam_dbg_log("EXIF_TAG_BRIGHTNESS_VALUE numerator [%d], denominator [%d]",
-		               avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator);
+			avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator);
 
 		b = malloc(sizeof(ExifSRational));
 		if (b) {
@@ -2509,17 +2482,17 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 			rsData.denominator = avsys_exif_info.brightness_denominator;
 			exif_set_srational(b, exif_data_get_byte_order(ed), rsData);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_BRIGHTNESS_VALUE,
-			                            EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
+				EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
 			free(b);
 			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_BRIGHTNESS_VALUE);
 			}
 		} else {
-			_mmcam_dbg_warn( "malloc failed." );
+			_mmcam_dbg_warn("malloc failed.");
 		}
 	} else {
 		_mmcam_dbg_log("Skip set EXIF_TAG_BRIGHTNESS_VALUE numerator [%d], denominatorr [%d]",
-		               avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator);
+			avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator);
 	}
 
 	/*21. EXIF_TAG_EXPOSURE_BIAS_VALUE*/
@@ -2530,7 +2503,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		ExifSRational rsData;
 
 		_mmcam_dbg_log("EXIF_TAG_BRIGHTNESS_VALUE %d, default %d, step denominator %d",
-		               value, hcamcorder->brightness_default, hcamcorder->brightness_step_denominator);
+			value, hcamcorder->brightness_default, hcamcorder->brightness_step_denominator);
 
 		b = malloc(sizeof(ExifSRational));
 		if (b) {
@@ -2543,7 +2516,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 			}
 			exif_set_srational(b, exif_data_get_byte_order(ed), rsData);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_BIAS_VALUE,
-			                            EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
+				EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
 			free(b);
 			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_BIAS_VALUE);
@@ -2569,7 +2542,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 			rData.denominator = 1;
 			exif_set_rational(b, exif_data_get_byte_order(ed), rData);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_MAX_APERTURE_VALUE,
-			                            EXIF_FORMAT_RATIONAL, 1, b);
+				EXIF_FORMAT_RATIONAL, 1, b);
 			free(b);
 			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_MAX_APERTURE_VALUE);
@@ -2585,10 +2558,10 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 
 	/*24. EXIF_TAG_METERING_MODE */
 	if (control != NULL) {
-		exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed),avsys_exif_info.metering_mode);
+		exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.metering_mode);
 		_mmcam_dbg_log("EXIF_TAG_METERING_MODE [%d]", avsys_exif_info.metering_mode);
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_METERING_MODE,
-		                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+			EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 		if (ret != MM_ERROR_NONE) {
 			EXIF_SET_ERR(ret, EXIF_TAG_METERING_MODE);
 		}
@@ -2598,10 +2571,10 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 
 	/*26. EXIF_TAG_FLASH*/
 	if (control != NULL) {
-		exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order (ed),avsys_exif_info.flash);
+		exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.flash);
 		_mmcam_dbg_log("EXIF_TAG_FLASH [%d]", avsys_exif_info.flash);
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FLASH,
-		                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+			EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 		if (ret != MM_ERROR_NONE) {
 			EXIF_SET_ERR(ret, EXIF_TAG_FLASH);
 		}
@@ -2613,7 +2586,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		ExifRational rData;
 
 		_mmcam_dbg_log("EXIF_TAG_FOCAL_LENGTH numerator [%d], denominator [%d]",
-		               avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator);
+			avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator);
 
 		b = malloc(sizeof(ExifRational));
 		if (b) {
@@ -2621,7 +2594,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 			rData.denominator = avsys_exif_info.focal_len_denominator;
 			exif_set_rational(b, exif_data_get_byte_order(ed), rData);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH,
-			                            EXIF_FORMAT_RATIONAL, 1, (const char *)b);
+				EXIF_FORMAT_RATIONAL, 1, (const char *)b);
 			free(b);
 			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_FOCAL_LENGTH);
@@ -2631,15 +2604,15 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		}
 	} else {
 		_mmcam_dbg_log("Skip set EXIF_TAG_FOCAL_LENGTH numerator [%d], denominator [%d]",
-		               avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator);
+			avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator);
 	}
 
 	/*28. EXIF_TAG_SENSING_METHOD*/
 	/*FIXME*/
 	value = MM_SENSING_MODE;
-	exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order (ed),value);
+	exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SENSING_METHOD,
-	                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+		EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 	if (ret != MM_ERROR_NONE) {
 		EXIF_SET_ERR(ret, EXIF_TAG_SENSING_METHOD);
 	}
@@ -2649,7 +2622,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	value = MM_FILE_SOURCE;
 	exif_set_long(&elong[cntl], exif_data_get_byte_order(ed),value);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FILE_SOURCE,
-	                            EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]);
+		EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]);
 	if (ret != MM_ERROR_NONE) {
 		EXIF_SET_ERR(ret, EXIF_TAG_FILE_SOURCE);
 	}
@@ -2660,7 +2633,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	value = MM_SCENE_TYPE;
 	exif_set_long(&elong[cntl], exif_data_get_byte_order(ed),value);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SCENE_TYPE,
-	                            EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]);
+		EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]);
 	if (ret != MM_ERROR_NONE) {
 		EXIF_SET_ERR(ret, EXIF_TAG_SCENE_TYPE);
 	}
@@ -2669,13 +2642,11 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	/*31. EXIF_TAG_EXPOSURE_MODE*/
 	/*FIXME*/
 	value = MM_EXPOSURE_MODE;
-	exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed),value);
+	exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_MODE,
-	                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
-	if (ret != MM_ERROR_NONE) {
+		EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+	if (ret != MM_ERROR_NONE)
 		EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_MODE);
-	}
-
 
 	/*32. EXIF_TAG_WHITE_BALANCE*/
 	ret = mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_WB, &value, NULL);
@@ -2683,15 +2654,14 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		int set_value = 0;
 		_mmcam_dbg_log("WHITE BALANCE [%d]", value);
 
-		if (value == MM_CAMCORDER_WHITE_BALANCE_AUTOMATIC) {
+		if (value == MM_CAMCORDER_WHITE_BALANCE_AUTOMATIC)
 			set_value = 0;
-		} else {
+		else
 			set_value = 1;
-		}
 
 		exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), set_value);
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_WHITE_BALANCE,
-		                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+			EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 		if (ret != MM_ERROR_NONE) {
 			EXIF_SET_ERR(ret, EXIF_TAG_WHITE_BALANCE);
 		}
@@ -2707,7 +2677,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 
 		exif_set_long(&elong[cntl], exif_data_get_byte_order(ed), value);
 		ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_DIGITAL_ZOOM_RATIO,
-		                            EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
+			EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
 		if (ret != MM_ERROR_NONE) {
 			EXIF_SET_ERR(ret, EXIF_TAG_DIGITAL_ZOOM_RATIO);
 		}
@@ -2722,7 +2692,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	value = MM_FOCAL_LENGTH_35MMFILM;
 	exif_set_short(&eshort[cnts], exif_data_get_byte_order(ed),value);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM,
-	                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+		EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 	if (ret != MM_ERROR_NONE) {
 		EXIF_SET_ERR(ret, EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM);
 	}
@@ -2750,7 +2720,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 
 			exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), scene_capture_type);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SCENE_CAPTURE_TYPE,
-			                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+				EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_SCENE_CAPTURE_TYPE);
 			}
@@ -2765,7 +2735,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	value = MM_GAIN_CONTROL;
 	exif_set_long(&elong[cntl], exif_data_get_byte_order(ed), value);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_GAIN_CONTROL,
-	                            EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
+		EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
 	if (ret != MM_ERROR_NONE) {
 		EXIF_SET_ERR(ret, EXIF_TAG_GAIN_CONTROL);
 	}
@@ -2778,9 +2748,9 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		int level = 0;
 
 		_mmcamcorder_conf_get_value_int_range(hcamcorder->conf_ctrl,
-		                                      CONFIGURE_CATEGORY_CTRL_EFFECT,
-		                                      "Contrast",
-		                                      &irange);
+			CONFIGURE_CATEGORY_CTRL_EFFECT,
+			"Contrast",
+			&irange);
 		if (irange != NULL) {
 			mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_CONTRAST, &value, NULL);
 
@@ -2796,7 +2766,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 
 			exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_CONTRAST,
-			                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+				EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_CONTRAST);
 			}
@@ -2811,9 +2781,9 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		int level = 0;
 
 		_mmcamcorder_conf_get_value_int_range(hcamcorder->conf_ctrl,
-		                                      CONFIGURE_CATEGORY_CTRL_EFFECT,
-		                                      "Saturation",
-		                                      &irange);
+			CONFIGURE_CATEGORY_CTRL_EFFECT,
+			"Saturation",
+			&irange);
 		if (irange != NULL) {
 			mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SATURATION, &value, NULL);
 
@@ -2824,12 +2794,12 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 			} else if (value < irange->default_value) {
 				level = MM_VALUE_LOW;
 			} else {
-				level=MM_VALUE_HARD;
+				level = MM_VALUE_HARD;
 			}
 
 			exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SATURATION,
-			                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+				EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_SATURATION);
 			}
@@ -2844,9 +2814,9 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 		int level = 0;
 
 		_mmcamcorder_conf_get_value_int_range(hcamcorder->conf_ctrl,
-		                                      CONFIGURE_CATEGORY_CTRL_EFFECT,
-		                                      "Sharpness",
-		                                      &irange);
+			CONFIGURE_CATEGORY_CTRL_EFFECT,
+			"Sharpness",
+			&irange);
 		if (irange != NULL) {
 			mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SHARPNESS, &value, NULL);
 
@@ -2862,7 +2832,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 
 			exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level);
 			ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SHARPNESS,
-			                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+				EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 			if (ret != MM_ERROR_NONE) {
 				EXIF_SET_ERR(ret, EXIF_TAG_SHARPNESS);
 			}
@@ -2877,7 +2847,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	_mmcam_dbg_log("DISTANCE_RANGE [%d]", value);
 	exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value);
 	ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SUBJECT_DISTANCE_RANGE,
-	                            EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+		EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
 	if (ret != MM_ERROR_NONE) {
 		EXIF_SET_ERR(ret, EXIF_TAG_SUBJECT_DISTANCE_RANGE);
 	}
@@ -2888,16 +2858,14 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int
 	_mmcam_dbg_log("");
 
 	ret = mm_exif_set_exif_to_info(hcamcorder->exif_info, ed);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		_mmcam_dbg_err("mm_exif_set_exif_to_info err!! [%x]", ret);
-	}
 
 exit:
 	_mmcam_dbg_log("finished!! [%x]", ret);
 
-	if (ed) {
-		exif_data_unref (ed);
-	}
+	if (ed)
+		exif_data_unref(ed);
 
 	return ret;
 }
diff --git a/src/mm_camcorder_util.c b/src/mm_camcorder_util.c
index 79b3b3b..37fdad7 100644
--- a/src/mm_camcorder_util.c
+++ b/src/mm_camcorder_util.c
@@ -49,22 +49,20 @@
 #define TIME_STRING_MAX_LEN                     64
 #define __MMCAMCORDER_CAPTURE_WAIT_TIMEOUT      5
 
-#define FPUTC_CHECK(x_char, x_file)\
-{\
-	if (fputc(x_char, x_file) == EOF) \
-	{\
-		_mmcam_dbg_err("[Critical] fputc() returns fail.\n");	\
-		return FALSE;\
-	}\
+#define FPUTC_CHECK(x_char, x_file) \
+{ \
+	if (fputc(x_char, x_file) == EOF) { \
+		_mmcam_dbg_err("[Critical] fputc() returns fail.\n"); \
+		return FALSE; \
+	} \
 }
-#define FPUTS_CHECK(x_str, x_file)\
-{\
-	if (fputs(x_str, x_file) == EOF) \
-	{\
-		_mmcam_dbg_err("[Critical] fputs() returns fail.\n");\
-		SAFE_G_FREE(str);	\
-		return FALSE;\
-	}\
+#define FPUTS_CHECK(x_str, x_file) \
+{ \
+	if (fputs(x_str, x_file) == EOF) { \
+		_mmcam_dbg_err("[Critical] fputs() returns fail.\n"); \
+		SAFE_G_FREE(str); \
+		return FALSE; \
+	} \
 }
 
 /*---------------------------------------------------------------------------
@@ -72,7 +70,7 @@
 ---------------------------------------------------------------------------*/
 /* STATIC INTERNAL FUNCTION */
 
-//static gint 		skip_mdat(FILE *f);
+//static gint            skip_mdat(FILE *f);
 static guint16           get_language_code(const char *str);
 static gchar*            str_to_utf8(const gchar *str);
 static inline gboolean   write_tag(FILE *f, const gchar *tag);
@@ -90,7 +88,7 @@ static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint widt
 /*===========================================================================================
 |																							|
 |  FUNCTION DEFINITIONS																		|
-|  																							|
+|																							|
 ========================================================================================== */
 /*---------------------------------------------------------------------------
 |    GLOBAL FUNCTION DEFINITIONS:											|
@@ -218,7 +216,7 @@ static int __gdbus_wait_for_cb_return(_MMCamcorderGDbusCbInfo *gdbus_info, int t
 		return MM_ERROR_NONE;
 	}
 
-	end_time = g_get_monotonic_time()+ (time_out * G_TIME_SPAN_MILLISECOND);
+	end_time = g_get_monotonic_time() + (time_out * G_TIME_SPAN_MILLISECOND);
 
 	if (g_cond_wait_until(&gdbus_info->sync_cond, &gdbus_info->sync_mutex, end_time)) {
 		_mmcam_dbg_log("wait signal received");
@@ -244,9 +242,8 @@ gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc, gboolean do_rewind)
 	size_t read_item = 0;
 	guchar buf[8];
 
-	if (do_rewind) {
+	if (do_rewind)
 		rewind(f);
-	}
 
 	while ((read_item = fread(&buf, sizeof(guchar), 8, f)) > 0) {
 		uint64_t buf_size = 0;
@@ -268,7 +265,7 @@ gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc, gboolean do_rewind)
 			buf_size = _mmcamcorder_get_container_size(buf);
 
 			/* if size of mdat is 1, it means largesize is used.(bigger than 4GB) */
-			if (buf_fourcc == MMCAM_FOURCC('m','d','a','t') &&
+			if (buf_fourcc == MMCAM_FOURCC('m', 'd', 'a', 't') &&
 			    buf_size == 1) {
 				read_item = fread(&buf, sizeof(guchar), 8, f);
 				if (read_item < 8) {
@@ -300,9 +297,8 @@ gboolean _mmcamcorder_find_fourcc(FILE *f, guint32 tag_fourcc, gboolean do_rewin
 	size_t read_item = 0;
 	guchar buf[8];
 
-	if (do_rewind) {
+	if (do_rewind)
 		rewind(f);
-	}
 
 	while ((read_item = fread(&buf, sizeof(guchar), 8, f))  > 0) {
 		uint64_t buf_size = 0;
@@ -318,20 +314,19 @@ gboolean _mmcamcorder_find_fourcc(FILE *f, guint32 tag_fourcc, gboolean do_rewin
 		if (tag_fourcc == buf_fourcc) {
 			_mmcam_dbg_log("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
 			return TRUE;
-		} else if (buf_fourcc == MMCAM_FOURCC('m','o','o','v') &&
-		           tag_fourcc != buf_fourcc) {
-			if (_mmcamcorder_find_fourcc(f, tag_fourcc, FALSE)) {
+		} else if (buf_fourcc == MMCAM_FOURCC('m', 'o', 'o', 'v') &&
+				   tag_fourcc != buf_fourcc) {
+			if (_mmcamcorder_find_fourcc(f, tag_fourcc, FALSE))
 				return TRUE;
-			} else {
+			else
 				continue;
-			}
 		} else {
 			_mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc));
 
 			buf_size = _mmcamcorder_get_container_size(buf);
 
 			/* if size of mdat is 1, it means largesize is used.(bigger than 4GB) */
-			if (buf_fourcc == MMCAM_FOURCC('m','d','a','t') &&
+			if (buf_fourcc == MMCAM_FOURCC('m', 'd', 'a', 't') &&
 			    buf_size == 1) {
 				read_item = fread(&buf, sizeof(guchar), 8, f);
 				if (read_item < 8) {
@@ -361,8 +356,7 @@ gboolean _mmcamcorder_find_fourcc(FILE *f, guint32 tag_fourcc, gboolean do_rewin
 gboolean _mmcamcorder_update_size(FILE *f, gint64 prev_pos, gint64 curr_pos)
 {
 	_mmcam_dbg_log("size : %"G_GINT64_FORMAT"", curr_pos-prev_pos);
-	if(fseeko(f, prev_pos, SEEK_SET) != 0)
-	{
+	if (fseeko(f, prev_pos, SEEK_SET) != 0) {
 		_mmcam_dbg_err("fseeko() fail");
 		return FALSE;
 	}
@@ -370,8 +364,7 @@ gboolean _mmcamcorder_update_size(FILE *f, gint64 prev_pos, gint64 curr_pos)
 	if (!write_to_32(f, curr_pos -prev_pos))
 		return FALSE;
 
-	if(fseeko(f, curr_pos, SEEK_SET) != 0)
-	{
+	if (fseeko(f, curr_pos, SEEK_SET) != 0) {
 		_mmcam_dbg_err("fseeko() fail");
 		return FALSE;
 	}
@@ -386,24 +379,23 @@ gboolean _mmcamcorder_write_loci(FILE *f, _MMCamcorderLocationInfo info)
 
 	_mmcam_dbg_log("");
 
-	if((pos = ftello(f))<0)
-	{
+	if ((pos = ftello(f)) < 0) {
 		_mmcam_dbg_err("ftello() returns negative value");
 		return FALSE;
 	}
 
-	if(!write_to_32(f, 0)) //size
+	if (!write_to_32(f, 0)) //size
 		return FALSE;
 
-	if(!write_tag(f, "loci")) 	// type
+	if (!write_tag(f, "loci")) // type
 		return FALSE;
 
 	FPUTC_CHECK(0, f);		// version
 
-	if(!write_to_24(f, 0))	// flags
+	if (!write_to_24(f, 0))	// flags
 		return FALSE;
 
-	if(!write_to_16(f, get_language_code("eng"))) // language
+	if (!write_to_16(f, get_language_code("eng"))) // language
 		return FALSE;
 
 	str = str_to_utf8("location_name");
@@ -414,13 +406,13 @@ gboolean _mmcamcorder_write_loci(FILE *f, _MMCamcorderLocationInfo info)
 	FPUTC_CHECK('\0', f);
 	FPUTC_CHECK(0, f);		//role
 
-	if(!write_to_32(f, info.longitude))	// Longitude
+	if (!write_to_32(f, info.longitude))	// Longitude
 		return FALSE;
 
-	if(!write_to_32(f, info.latitude)) // Latitude
+	if (!write_to_32(f, info.latitude)) // Latitude
 		return FALSE;
 
-	if(! write_to_32(f, info.altitude))	// Altitude
+	if (!write_to_32(f, info.altitude))	// Altitude
 		return FALSE;
 
 	str = str_to_utf8("Astronomical_body");
@@ -435,63 +427,62 @@ gboolean _mmcamcorder_write_loci(FILE *f, _MMCamcorderLocationInfo info)
 
 	FPUTC_CHECK('\0', f);
 
-	if((current_pos = ftello(f))<0)
-	{
+	if ((current_pos = ftello(f)) < 0) {
 		_mmcam_dbg_err("ftello() returns negative value");
 		return FALSE;
 	}
 
-	if(! _mmcamcorder_update_size(f, pos, current_pos))
+	if (!_mmcamcorder_update_size(f, pos, current_pos))
 		return FALSE;
 
 	return TRUE;
 }
 
-void _mmcamcorder_write_Latitude(FILE *f,int value) {
+void _mmcamcorder_write_Latitude(FILE *f, int value)
+{
 	char s_latitude[9];
 	int l_decimal = 0;
 	int l_below_decimal = 0;
 
 	l_decimal = value / 10000;
 	if (value < 0) {
-		if( l_decimal == 0) {
+		if (l_decimal == 0)
 			snprintf(s_latitude, 5, "-%.2d.", l_decimal);
-		} else {
+		else
 			snprintf(s_latitude, 5, "%.2d.", l_decimal);
-		}
 	} else {
 		snprintf(s_latitude, 5, "+%.2d.", l_decimal);
 	}
 
 	l_below_decimal = value - (l_decimal * 10000);
-	if (l_below_decimal < 0) {
+	if (l_below_decimal < 0)
 		l_below_decimal = -l_below_decimal;
-	}
+
 	snprintf(&s_latitude[4], 5, "%.4d", l_below_decimal);
 
 	write_tag(f, s_latitude);
 }
 
-void _mmcamcorder_write_Longitude(FILE *f,int value) {
+void _mmcamcorder_write_Longitude(FILE *f, int value)
+{
 	char s_longitude[10];
 	int l_decimal = 0;
 	int l_below_decimal = 0;
 
 	l_decimal = value / 10000;
 	if (value < 0) {
-		if( l_decimal == 0) {
+		if (l_decimal == 0)
 			snprintf(s_longitude, 6, "-%.3d.", l_decimal);
-		} else {
+		else
 			snprintf(s_longitude, 6, "%.3d.", l_decimal);
-		}
 	} else {
 		snprintf(s_longitude, 6, "+%.3d.", l_decimal);
 	}
 
 	l_below_decimal = value - (l_decimal * 10000);
-	if (l_below_decimal < 0) {
+	if (l_below_decimal < 0)
 		l_below_decimal = -l_below_decimal;
-	}
+
 	snprintf(&s_longitude[5], 5, "%.4d", l_below_decimal);
 
 	write_tag(f, s_longitude);
@@ -502,39 +493,37 @@ void _mmcamcorder_write_Longitude(FILE *f,int value) {
 // 0x15c7 -> encode in english
 #define D_INFO_GEOGRAPH 0x001215c7
 
-gboolean _mmcamcorder_write_geodata(FILE *f,_MMCamcorderLocationInfo info) {
-
+gboolean _mmcamcorder_write_geodata(FILE *f, _MMCamcorderLocationInfo info)
+{
 	gint64 current_pos, pos;
 
 	_mmcam_dbg_log("");
 
-	if((pos = ftello(f))<0)
-	{
+	if ((pos = ftello(f)) < 0) {
 		_mmcam_dbg_err("ftello() returns negative value");
 		return FALSE;
 	}
 
-	if(!write_to_32(f, 0)) 	//size
+	if (!write_to_32(f, 0))			//size
 		return FALSE;
 	// tag -> .xyz
-	if(!write_tag(f, D_GEOGRAPH)) 	// type
+	if (!write_tag(f, D_GEOGRAPH))	// type
 		return FALSE;
 
-	if(!write_to_32(f, D_INFO_GEOGRAPH))
+	if (!write_to_32(f, D_INFO_GEOGRAPH))
 		return FALSE;
 
-	_mmcamcorder_write_Latitude(f,info.latitude);
-	_mmcamcorder_write_Longitude(f,info.longitude);
+	_mmcamcorder_write_Latitude(f, info.latitude);
+	_mmcamcorder_write_Longitude(f, info.longitude);
 
 	FPUTC_CHECK(0x2F, f);
 
-	if((current_pos = ftello(f))<0)
-	{
+	if ((current_pos = ftello(f)) < 0) {
 		_mmcam_dbg_err("ftello() returns negative value");
 		return FALSE;
 	}
 
-	if(! _mmcamcorder_update_size(f, pos, current_pos))
+	if (!_mmcamcorder_update_size(f, pos, current_pos))
 		return FALSE;
 
 	return TRUE;
@@ -551,7 +540,7 @@ gboolean _mmcamcorder_write_udta(FILE *f, int gps_enable, _MMCamcorderLocationIn
 		return TRUE;
 	}
 
-	if ((pos = ftello(f))<0) {
+	if ((pos = ftello(f)) < 0) {
 		_mmcam_dbg_err("ftello() returns negative value");
 		return FALSE;
 	}
@@ -574,13 +563,13 @@ gboolean _mmcamcorder_write_udta(FILE *f, int gps_enable, _MMCamcorderLocationIn
 			return FALSE;
 		}
 
-		if (!_mmcamcorder_write_geodata(f,geotag)) {
+		if (!_mmcamcorder_write_geodata(f, geotag)) {
 			_mmcam_dbg_err("failed to write geodata");
 			return FALSE;
 		}
 	}
 
-	if ((current_pos = ftello(f))<0) {
+	if ((current_pos = ftello(f)) < 0) {
 		_mmcam_dbg_err("ftello() returns negative value");
 		return FALSE;
 	}
@@ -683,7 +672,7 @@ gboolean _mmcamcorder_update_composition_matrix(FILE *f, int orientation)
 	write_to_32(f, 0x40000000);
 
 	_mmcam_dbg_log("orientation : %d, write data 0x%x 0x%x 0x%x 0x%x",
-	               orientation, a, b, c, d);
+				   orientation, a, b, c, d);
 
 	return TRUE;
 }
@@ -716,18 +705,16 @@ int _mmcamcorder_get_freespace(const gchar *path, const gchar *root_directory, g
 			return -1;
 		}
 
-		if (stat_path.st_dev != stat_root.st_dev) {
+		if (stat_path.st_dev != stat_root.st_dev)
 			is_internal = FALSE;
-		}
 	} else {
 		_mmcam_dbg_warn("root_directory is NULL, assume that it's internal storage.");
 	}
 
-	if (is_internal) {
+	if (is_internal)
 		ret = storage_get_internal_memory_size(&vfs);
-	} else {
+	else
 		ret = storage_get_external_memory_size(&vfs);
-	}
 
 	if (ret < 0) {
 		*free_space = 0;
@@ -848,9 +835,8 @@ int _mmcamcorder_send_sound_play_message(GDBusConnection *conn, _MMCamcorderGDbu
 
 	g_mutex_unlock(&gdbus_info->sync_mutex);
 
-	if (sync_play && ret == MM_ERROR_NONE) {
+	if (sync_play && ret == MM_ERROR_NONE)
 		ret = __gdbus_wait_for_cb_return(gdbus_info, G_DBUS_CB_TIMEOUT_MSEC);
-	}
 
 	return ret;
 }
@@ -894,7 +880,7 @@ void _mmcamcorder_remove_buffer_probe(MMHandleType handle, _MMCamcorderHandlerCa
 		if (item->category & category) {
 			if (item->object && GST_IS_PAD(item->object)) {
 				_mmcam_dbg_log("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]",
-				               GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
+					GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
 				gst_pad_remove_probe(GST_PAD(item->object), item->handler_id);
 			} else {
 				_mmcam_dbg_warn("Remove buffer probe faild, the pad is null or not pad, just remove item from list and free it");
@@ -947,7 +933,7 @@ void _mmcamcorder_remove_one_buffer_probe(MMHandleType handle, void *object)
 		if (item->object && item->object == object) {
 			if (GST_IS_PAD(item->object)) {
 				_mmcam_dbg_log("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]",
-				               GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
+					GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
 				gst_pad_remove_probe(GST_PAD(item->object), item->handler_id);
 			} else {
 				_mmcam_dbg_warn("Remove buffer probe faild, the pad is null or not pad, just remove item from list and free it");
@@ -997,7 +983,7 @@ void _mmcamcorder_remove_event_probe(MMHandleType handle, _MMCamcorderHandlerCat
 		if (item->category & category) {
 			if (item->object && GST_IS_PAD(item->object)) {
 				_mmcam_dbg_log("Remove event probe on [%s:%s] - [ID : %lu], [Category : %x]",
-				               GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
+					GST_DEBUG_PAD_NAME(item->object), item->handler_id,  item->category);
 				gst_pad_remove_probe(GST_PAD(item->object), item->handler_id);
 			} else {
 				_mmcam_dbg_warn("Remove event probe faild, the pad is null or not pad, just remove item from list and free it");
@@ -1051,11 +1037,11 @@ void _mmcamcorder_disconnect_signal(MMHandleType handle, _MMCamcorderHandlerCate
 			if (item->object && GST_IS_ELEMENT(item->object)) {
 				if (g_signal_handler_is_connected(item->object, item->handler_id)) {
 					_mmcam_dbg_log("Disconnect signal from [%s] : [ID : %lu], [Category : %x]",
-					               GST_OBJECT_NAME(item->object), item->handler_id,  item->category);
+						GST_OBJECT_NAME(item->object), item->handler_id, item->category);
 					g_signal_handler_disconnect(item->object, item->handler_id);
 				} else {
 					_mmcam_dbg_warn("Signal was not connected, cannot disconnect it :  [%s]  [ID : %lu], [Category : %x]",
-					                GST_OBJECT_NAME(item->object), item->handler_id,  item->category);
+						GST_OBJECT_NAME(item->object), item->handler_id, item->category);
 				}
 			} else {
 				_mmcam_dbg_err("Fail to Disconnecting signal, the element is null or not element, just remove item from list and free it");
@@ -1087,11 +1073,11 @@ void _mmcamcorder_remove_all_handlers(MMHandleType handle,  _MMCamcorderHandlerC
 
 	_mmcam_dbg_log("ENTER");
 
-	if(hcamcorder->signals)
+	if (hcamcorder->signals)
 		_mmcamcorder_disconnect_signal((MMHandleType)hcamcorder, category);
-	if(hcamcorder->event_probes)
+	if (hcamcorder->event_probes)
 		_mmcamcorder_remove_event_probe((MMHandleType)hcamcorder, category);
-	if(hcamcorder->buffer_probes)
+	if (hcamcorder->buffer_probes)
 		_mmcamcorder_remove_buffer_probe((MMHandleType)hcamcorder, category);
 
 	_mmcam_dbg_log("LEAVE");
@@ -1100,7 +1086,7 @@ void _mmcamcorder_remove_all_handlers(MMHandleType handle,  _MMCamcorderHandlerC
 
 void _mmcamcorder_element_release_noti(gpointer data, GObject *where_the_object_was)
 {
-	int i=0;
+	int i = 0;
 	_MMCamcorderSubContext *sc = (_MMCamcorderSubContext *)data;
 
 	mmf_return_if_fail(sc);
@@ -1108,8 +1094,7 @@ void _mmcamcorder_element_release_noti(gpointer data, GObject *where_the_object_
 
 	for (i = 0 ; i < _MMCAMCORDER_PIPELINE_ELEMENT_NUM ; i++) {
 		if (sc->element[i].gst && (G_OBJECT(sc->element[i].gst) == where_the_object_was)) {
-			_mmcam_dbg_warn("The element[%d][%p] is finalized",
-			                sc->element[i].id, sc->element[i].gst);
+			_mmcam_dbg_warn("The element[%d][%p] is finalized", sc->element[i].id, sc->element[i].gst);
 			sc->element[i].gst = NULL;
 			sc->element[i].id = _MMCAMCORDER_NONE;
 			return;
@@ -1120,8 +1105,7 @@ void _mmcamcorder_element_release_noti(gpointer data, GObject *where_the_object_
 
 	for (i = 0 ; i < _MMCAMCORDER_ENCODE_PIPELINE_ELEMENT_NUM ; i++) {
 		if (sc->encode_element[i].gst && (G_OBJECT(sc->encode_element[i].gst) == where_the_object_was)) {
-			_mmcam_dbg_warn("The encode element[%d][%p] is finalized",
-			                sc->encode_element[i].id, sc->encode_element[i].gst);
+			_mmcam_dbg_warn("The encode element[%d][%p] is finalized", sc->encode_element[i].id, sc->encode_element[i].gst);
 			sc->encode_element[i].gst = NULL;
 			sc->encode_element[i].id = _MMCAMCORDER_ENCODE_NONE;
 			return;
@@ -1164,9 +1148,8 @@ gboolean _mmcamcorder_msg_callback(void *data)
 
 	_MMCAMCORDER_LOCK_MESSAGE_CALLBACK(hcamcorder);
 
-	if ((hcamcorder) && (hcamcorder->msg_cb)) {
+	if ((hcamcorder) && (hcamcorder->msg_cb))
 		hcamcorder->msg_cb(item->id, (MMMessageParamType*)(&(item->param)), hcamcorder->msg_cb_param);
-	}
 
 	_MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder);
 
@@ -1183,13 +1166,12 @@ MSG_CALLBACK_DONE:
 			item->param.data = NULL;
 			item->param.size = 0;
 		}
-	} else if (item->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED ||
-	           item->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
+	} else if (item->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || item->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
 		MMCamRecordingReport *report = (MMCamRecordingReport *)item->param.data;
 		if (report) {
-			if (report->recording_filename) {
+			if (report->recording_filename)
 				SAFE_G_FREE(report->recording_filename);
-			}
+
 			SAFE_G_FREE(report);
 			item->param.data = NULL;
 		}
@@ -1216,34 +1198,33 @@ gboolean _mmcamcorder_send_message(MMHandleType handle, _MMCamcorderMsgItem *dat
 	mmf_return_val_if_fail(hcamcorder, FALSE);
 	mmf_return_val_if_fail(data, FALSE);
 
-	switch (data->id)
-	{
-		case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
-		case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
-		case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_RM:
-			data->param.union_type = MM_MSG_UNION_STATE;
-			break;
-		case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
-			data->param.union_type = MM_MSG_UNION_RECORDING_STATUS;
-			break;
-		case MM_MESSAGE_CAMCORDER_FIRMWARE_UPDATE:
-			data->param.union_type = MM_MSG_UNION_FIRMWARE;
-			break;
-		case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
-			data->param.union_type = MM_MSG_UNION_REC_VOLUME_DB;
-			break;
-		case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
-		case MM_MESSAGE_CAMCORDER_MAX_SIZE:
-		case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
-		case MM_MESSAGE_CAMCORDER_ERROR:
-		case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED:
-		case MM_MESSAGE_CAMCORDER_CAPTURED:
-		case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED:
-		case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED:
-		case MM_MESSAGE_READY_TO_RESUME:
-		default:
-			data->param.union_type = MM_MSG_UNION_CODE;
-			break;
+	switch (data->id) {
+	case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
+	case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
+	case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_RM:
+		data->param.union_type = MM_MSG_UNION_STATE;
+		break;
+	case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
+		data->param.union_type = MM_MSG_UNION_RECORDING_STATUS;
+		break;
+	case MM_MESSAGE_CAMCORDER_FIRMWARE_UPDATE:
+		data->param.union_type = MM_MSG_UNION_FIRMWARE;
+		break;
+	case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
+		data->param.union_type = MM_MSG_UNION_REC_VOLUME_DB;
+		break;
+	case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
+	case MM_MESSAGE_CAMCORDER_MAX_SIZE:
+	case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
+	case MM_MESSAGE_CAMCORDER_ERROR:
+	case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED:
+	case MM_MESSAGE_CAMCORDER_CAPTURED:
+	case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED:
+	case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED:
+	case MM_MESSAGE_READY_TO_RESUME:
+	default:
+		data->param.union_type = MM_MSG_UNION_CODE;
+		break;
 	}
 
 #ifdef _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK
@@ -1267,11 +1248,10 @@ gboolean _mmcamcorder_send_message(MMHandleType handle, _MMCamcorderMsgItem *dat
 #else /* _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK */
 	_MMCAMCORDER_LOCK_MESSAGE_CALLBACK(hcamcorder);
 
-	if (hcamcorder->msg_cb) {
+	if (hcamcorder->msg_cb)
 		hcamcorder->msg_cb(data->id, (MMMessageParamType*)(&(data->param)), hcamcorder->msg_cb_param);
-	} else {
+	else
 		_mmcam_dbg_log("message callback is NULL. message id %d", data->id);
-	}
 
 	_MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder);
 
@@ -1283,8 +1263,7 @@ gboolean _mmcamcorder_send_message(MMHandleType handle, _MMCamcorderMsgItem *dat
 			SAFE_G_FREE(cam_fd_info);
 			data->param.size = 0;
 		}
-	} else if (data->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED ||
-	           data->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
+	} else if (data->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || data->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
 		MMCamRecordingReport *report = (MMCamRecordingReport *)data->param.data;
 		if (report) {
 			SAFE_G_FREE(report->recording_filename);
@@ -1343,12 +1322,11 @@ void _mmcamcorder_remove_message_all(MMHandleType handle)
 							item->param.size = 0;
 						}
 						SAFE_G_FREE(cam_fd_info);
-					} else if (item->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED ||
-					           item->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
+					} else if (item->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || item->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
 						MMCamRecordingReport *report = (MMCamRecordingReport *)item->param.data;
-						if (report) {
+						if (report)
 							SAFE_G_FREE(report->recording_filename);
-						}
+
 						SAFE_G_FREE(report);
 					}
 
@@ -1368,11 +1346,10 @@ void _mmcamcorder_remove_message_all(MMHandleType handle)
 
 					end_time = g_get_monotonic_time() + (100 * G_TIME_SPAN_MILLISECOND);
 
-					if (_MMCAMCORDER_WAIT_UNTIL(handle, end_time)) {
+					if (_MMCAMCORDER_WAIT_UNTIL(handle, end_time))
 						_mmcam_dbg_warn("signal received");
-					} else {
+					else
 						_mmcam_dbg_warn("timeout");
-					}
 				}
 			}
 		}
@@ -1402,36 +1379,36 @@ int _mmcamcorder_get_pixel_format(GstCaps *caps)
 	MMPixelFormatType type = 0;
 	unsigned int fourcc = 0;
 
-	mmf_return_val_if_fail( caps != NULL, MM_PIXEL_FORMAT_INVALID );
+	mmf_return_val_if_fail(caps != NULL, MM_PIXEL_FORMAT_INVALID);
 
-	structure = gst_caps_get_structure (caps, 0);
-	media_type = gst_structure_get_name (structure);
+	structure = gst_caps_get_structure(caps, 0);
+	media_type = gst_structure_get_name(structure);
 	if (media_type == NULL) {
 		_mmcam_dbg_err("failed to get media_type");
 		return MM_PIXEL_FORMAT_INVALID;
 	}
 
-	gst_video_info_init (&media_info);
+	gst_video_info_init(&media_info);
 
-	if (!strcmp (media_type, "image/jpeg") ) {
+	if (!strcmp(media_type, "image/jpeg")) {
 		_mmcam_dbg_log("It is jpeg.");
 		type = MM_PIXEL_FORMAT_ENCODED;
-	} else if (!strcmp (media_type, "video/x-raw") &&
+	} else if (!strcmp(media_type, "video/x-raw") &&
 		   gst_video_info_from_caps(&media_info, caps) &&
 		   GST_VIDEO_INFO_IS_YUV(&media_info)) {
 		_mmcam_dbg_log("It is yuv.");
 		fourcc = gst_video_format_to_fourcc(GST_VIDEO_INFO_FORMAT(&media_info));
 		type = _mmcamcorder_get_pixtype(fourcc);
-	} else if (!strcmp (media_type, "video/x-raw") &&
+	} else if (!strcmp(media_type, "video/x-raw") &&
 		   gst_video_info_from_caps(&media_info, caps) &&
 		   GST_VIDEO_INFO_IS_RGB(&media_info)) {
 		_mmcam_dbg_log("It is rgb.");
 		type = MM_PIXEL_FORMAT_RGB888;
-	} else if (!strcmp (media_type, "video/x-h264")) {
+	} else if (!strcmp(media_type, "video/x-h264")) {
 		_mmcam_dbg_log("It is H264");
 		type = MM_PIXEL_FORMAT_ENCODED_H264;
 	} else {
-		_mmcam_dbg_err("Not supported format [%s]",media_type);
+		_mmcam_dbg_err("Not supported format [%s]", media_type);
 		type = MM_PIXEL_FORMAT_INVALID;
 	}
 
@@ -1448,79 +1425,79 @@ unsigned int _mmcamcorder_get_fourcc(int pixtype, int codectype, int use_zero_co
 
 	switch (pixtype) {
 	case MM_PIXEL_FORMAT_NV12:
-		if (use_zero_copy_format) {
-			fourcc = GST_MAKE_FOURCC ('S', 'N', '1', '2');
-		} else {
-			fourcc = GST_MAKE_FOURCC ('N', 'V', '1', '2');
-		}
+		if (use_zero_copy_format)
+			fourcc = GST_MAKE_FOURCC('S', 'N', '1', '2');
+		else
+			fourcc = GST_MAKE_FOURCC('N', 'V', '1', '2');
+
 		break;
 	case MM_PIXEL_FORMAT_NV21:
-		if (use_zero_copy_format) {
-			fourcc = GST_MAKE_FOURCC ('S', 'N', '2', '1');
-		} else {
-			fourcc = GST_MAKE_FOURCC ('N', 'V', '2', '1');
-		}
+		if (use_zero_copy_format)
+			fourcc = GST_MAKE_FOURCC('S', 'N', '2', '1');
+		else
+			fourcc = GST_MAKE_FOURCC('N', 'V', '2', '1');
+
 		break;
 	case MM_PIXEL_FORMAT_YUYV:
-		if (use_zero_copy_format) {
-			fourcc = GST_MAKE_FOURCC ('S', 'U', 'Y', 'V');
-		} else {
-			fourcc = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
-		}
+		if (use_zero_copy_format)
+			fourcc = GST_MAKE_FOURCC('S', 'U', 'Y', 'V');
+		else
+			fourcc = GST_MAKE_FOURCC('Y', 'U', 'Y', '2');
+
 		break;
 	case MM_PIXEL_FORMAT_UYVY:
-		if (use_zero_copy_format) {
-			fourcc = GST_MAKE_FOURCC ('S', 'Y', 'V', 'Y');
-		} else {
-			fourcc = GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y');
-		}
+		if (use_zero_copy_format)
+			fourcc = GST_MAKE_FOURCC('S', 'Y', 'V', 'Y');
+		else
+			fourcc = GST_MAKE_FOURCC('U', 'Y', 'V', 'Y');
+
 		break;
 	case MM_PIXEL_FORMAT_I420:
-		if (use_zero_copy_format) {
-			fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0');
-		} else {
-			fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
-		}
+		if (use_zero_copy_format)
+			fourcc = GST_MAKE_FOURCC('S', '4', '2', '0');
+		else
+			fourcc = GST_MAKE_FOURCC('I', '4', '2', '0');
+
 		break;
 	case MM_PIXEL_FORMAT_YV12:
-		fourcc = GST_MAKE_FOURCC ('Y', 'V', '1', '2');
+		fourcc = GST_MAKE_FOURCC('Y', 'V', '1', '2');
 		break;
 	case MM_PIXEL_FORMAT_422P:
-		fourcc = GST_MAKE_FOURCC ('4', '2', '2', 'P');
+		fourcc = GST_MAKE_FOURCC('4', '2', '2', 'P');
 		break;
 	case MM_PIXEL_FORMAT_RGB565:
-		fourcc = GST_MAKE_FOURCC ('R', 'G', 'B', 'P');
+		fourcc = GST_MAKE_FOURCC('R', 'G', 'B', 'P');
 		break;
 	case MM_PIXEL_FORMAT_RGB888:
-		fourcc = GST_MAKE_FOURCC ('R', 'G', 'B', ' ');
+		fourcc = GST_MAKE_FOURCC('R', 'G', 'B', ' ');
 		break;
 	case MM_PIXEL_FORMAT_ENCODED:
 		if (codectype == MM_IMAGE_CODEC_JPEG) {
-			fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G');
+			fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G');
 		} else if (codectype == MM_IMAGE_CODEC_JPEG_SRW) {
-			fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G'); /*TODO: JPEG+SamsungRAW format */
+			fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G'); /*TODO: JPEG+SamsungRAW format */
 		} else if (codectype == MM_IMAGE_CODEC_SRW) {
-			fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G'); /*TODO: SamsungRAW format */
+			fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G'); /*TODO: SamsungRAW format */
 		} else if (codectype == MM_IMAGE_CODEC_PNG) {
-			fourcc = GST_MAKE_FOURCC ('P', 'N', 'G', ' ');
+			fourcc = GST_MAKE_FOURCC('P', 'N', 'G', ' ');
 		} else {
 			/* Please let us know what other fourcces are. ex) BMP, GIF?*/
-			fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G');
+			fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G');
 		}
 		break;
 	case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
-		fourcc = GST_MAKE_FOURCC('I','T','L','V');
+		fourcc = GST_MAKE_FOURCC('I', 'T', 'L', 'V');
 		break;
 	case MM_PIXEL_FORMAT_ENCODED_H264:
-		fourcc = GST_MAKE_FOURCC('H','2','6','4');
+		fourcc = GST_MAKE_FOURCC('H', '2', '6', '4');
 		break;
 	default:
 		_mmcam_dbg_log("Not proper pixel type[%d]. Set default - I420", pixtype);
-		if (use_zero_copy_format) {
-			fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0');
-		} else {
-			fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
-		}
+		if (use_zero_copy_format)
+			fourcc = GST_MAKE_FOURCC('S', '4', '2', '0');
+		else
+			fourcc = GST_MAKE_FOURCC('I', '4', '2', '0');
+
 		break;
 	}
 
@@ -1535,66 +1512,65 @@ int _mmcamcorder_get_pixtype(unsigned int fourcc)
 	char *pfourcc = (char*)&fourcc;
 
 	_mmcam_dbg_log("fourcc(%c%c%c%c)",
-	                 pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]);
+				   pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]);
 	*/
 
 	switch (fourcc) {
-	case GST_MAKE_FOURCC ('S', 'N', '1', '2'):
-	case GST_MAKE_FOURCC ('N', 'V', '1', '2'):
+	case GST_MAKE_FOURCC('S', 'N', '1', '2'):
+	case GST_MAKE_FOURCC('N', 'V', '1', '2'):
 		pixtype = MM_PIXEL_FORMAT_NV12;
 		break;
-	case GST_MAKE_FOURCC ('S', 'N', '2', '1'):
-	case GST_MAKE_FOURCC ('N', 'V', '2', '1'):
+	case GST_MAKE_FOURCC('S', 'N', '2', '1'):
+	case GST_MAKE_FOURCC('N', 'V', '2', '1'):
 		pixtype = MM_PIXEL_FORMAT_NV21;
 		break;
-	case GST_MAKE_FOURCC ('S', 'U', 'Y', 'V'):
-	case GST_MAKE_FOURCC ('Y', 'U', 'Y', 'V'):
-	case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
+	case GST_MAKE_FOURCC('S', 'U', 'Y', 'V'):
+	case GST_MAKE_FOURCC('Y', 'U', 'Y', 'V'):
+	case GST_MAKE_FOURCC('Y', 'U', 'Y', '2'):
 		pixtype = MM_PIXEL_FORMAT_YUYV;
 		break;
-	case GST_MAKE_FOURCC ('S', 'Y', 'V', 'Y'):
-	case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
+	case GST_MAKE_FOURCC('S', 'Y', 'V', 'Y'):
+	case GST_MAKE_FOURCC('U', 'Y', 'V', 'Y'):
 		pixtype = MM_PIXEL_FORMAT_UYVY;
 		break;
-	case GST_MAKE_FOURCC ('S', '4', '2', '0'):
-	case GST_MAKE_FOURCC ('I', '4', '2', '0'):
+	case GST_MAKE_FOURCC('S', '4', '2', '0'):
+	case GST_MAKE_FOURCC('I', '4', '2', '0'):
 		pixtype = MM_PIXEL_FORMAT_I420;
 		break;
-	case GST_MAKE_FOURCC ('Y', 'V', '1', '2'):
+	case GST_MAKE_FOURCC('Y', 'V', '1', '2'):
 		pixtype = MM_PIXEL_FORMAT_YV12;
 		break;
-	case GST_MAKE_FOURCC ('4', '2', '2', 'P'):
+	case GST_MAKE_FOURCC('4', '2', '2', 'P'):
 		pixtype = MM_PIXEL_FORMAT_422P;
 		break;
-	case GST_MAKE_FOURCC ('R', 'G', 'B', 'P'):
+	case GST_MAKE_FOURCC('R', 'G', 'B', 'P'):
 		pixtype = MM_PIXEL_FORMAT_RGB565;
 		break;
-	case GST_MAKE_FOURCC ('R', 'G', 'B', '3'):
+	case GST_MAKE_FOURCC('R', 'G', 'B', '3'):
 		pixtype = MM_PIXEL_FORMAT_RGB888;
 		break;
-	case GST_MAKE_FOURCC ('A', 'R', 'G', 'B'):
-	case GST_MAKE_FOURCC ('x', 'R', 'G', 'B'):
+	case GST_MAKE_FOURCC('A', 'R', 'G', 'B'):
+	case GST_MAKE_FOURCC('x', 'R', 'G', 'B'):
 		pixtype = MM_PIXEL_FORMAT_ARGB;
 		break;
-	case GST_MAKE_FOURCC ('B', 'G', 'R', 'A'):
-	case GST_MAKE_FOURCC ('B', 'G', 'R', 'x'):
-	case GST_MAKE_FOURCC ('S', 'R', '3', '2'):
+	case GST_MAKE_FOURCC('B', 'G', 'R', 'A'):
+	case GST_MAKE_FOURCC('B', 'G', 'R', 'x'):
+	case GST_MAKE_FOURCC('S', 'R', '3', '2'):
 		pixtype = MM_PIXEL_FORMAT_RGBA;
 		break;
-	case GST_MAKE_FOURCC ('J', 'P', 'E', 'G'):
-	case GST_MAKE_FOURCC ('P', 'N', 'G', ' '):
+	case GST_MAKE_FOURCC('J', 'P', 'E', 'G'):
+	case GST_MAKE_FOURCC('P', 'N', 'G', ' '):
 		pixtype = MM_PIXEL_FORMAT_ENCODED;
 		break;
 	/*FIXME*/
-	case GST_MAKE_FOURCC ('I', 'T', 'L', 'V'):
+	case GST_MAKE_FOURCC('I', 'T', 'L', 'V'):
 		pixtype = MM_PIXEL_FORMAT_ITLV_JPEG_UYVY;
 		break;
-	case GST_MAKE_FOURCC ('H', '2', '6', '4'):
+	case GST_MAKE_FOURCC('H', '2', '6', '4'):
 		pixtype = MM_PIXEL_FORMAT_ENCODED_H264;
 		break;
 	default:
-		_mmcam_dbg_log("Not supported fourcc type(%c%c%c%c)",
-		               fourcc, fourcc>>8, fourcc>>16, fourcc>>24);
+		_mmcam_dbg_log("Not supported fourcc type(%c%c%c%c)", fourcc, fourcc>>8, fourcc>>16, fourcc>>24);
 		pixtype = MM_PIXEL_FORMAT_INVALID;
 		break;
 	}
@@ -1614,14 +1590,14 @@ gboolean _mmcamcorder_add_elements_to_bin(GstBin *bin, GList *element_list)
 		element = (_MMCamcorderGstElement*)local_list->data;
 		if (element && element->gst) {
 			if (!gst_bin_add(bin, GST_ELEMENT(element->gst))) {
-				_mmcam_dbg_err( "Add element [%s] to bin [%s] FAILED",
-				                GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
-				                GST_ELEMENT_NAME(GST_ELEMENT(bin)) );
+				_mmcam_dbg_err("Add element [%s] to bin [%s] FAILED",
+					GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
+					GST_ELEMENT_NAME(GST_ELEMENT(bin)));
 				return FALSE;
 			} else {
 				_mmcam_dbg_log("Add element [%s] to bin [%s] OK",
-				               GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
-				               GST_ELEMENT_NAME(GST_ELEMENT(bin)));
+					GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
+					GST_ELEMENT_NAME(GST_ELEMENT(bin)));
 			}
 		}
 		local_list = local_list->next;
@@ -1646,12 +1622,12 @@ gboolean _mmcamcorder_link_elements(GList *element_list)
 		if (pre_element && pre_element->gst && element && element->gst) {
 			if (_MM_GST_ELEMENT_LINK(GST_ELEMENT(pre_element->gst), GST_ELEMENT(element->gst))) {
 				_mmcam_dbg_log("Link [%s] to [%s] OK",
-				               GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
-				               GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
+					GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
+					GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
 			} else {
 				_mmcam_dbg_err("Link [%s] to [%s] FAILED",
-				               GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
-				               GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
+					GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
+					GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
 				return FALSE;
 			}
 		}
@@ -1672,8 +1648,7 @@ gboolean _mmcamcorder_resize_frame(unsigned char *src_data, unsigned int src_wid
 	unsigned char *dst_tmp_data = NULL;
 
 	if (!src_data || !dst_data || !dst_width || !dst_height || !dst_length) {
-		_mmcam_dbg_err("something is NULL %p,%p,%p,%p,%p",
-		               src_data, dst_data, dst_width, dst_height, dst_length);
+		_mmcam_dbg_err("something is NULL %p,%p,%p,%p,%p", src_data, dst_data, dst_width, dst_height, dst_length);
 		return FALSE;
 	}
 
@@ -1702,8 +1677,7 @@ gboolean _mmcamcorder_resize_frame(unsigned char *src_data, unsigned int src_wid
 		return FALSE;
 	}
 
-	_mmcam_dbg_log("src size %dx%d -> dst size %dx%d",
-	                src_width, src_height, *dst_width, *dst_height);
+	_mmcam_dbg_log("src size %dx%d -> dst size %dx%d", src_width, src_height, *dst_width, *dst_height);
 
 	/* get length of resized image */
 	mm_ret = mm_util_get_image_size(input_format, *dst_width, *dst_height, dst_length);
@@ -1720,8 +1694,8 @@ gboolean _mmcamcorder_resize_frame(unsigned char *src_data, unsigned int src_wid
 		return FALSE;
 	}
 
-	mm_ret = mm_util_resize_image(src_data, src_width, src_height, input_format,
-	                              dst_tmp_data, dst_width, dst_height);
+	mm_ret = mm_util_resize_image(src_data, src_width, src_height, input_format, dst_tmp_data, dst_width, dst_height);
+
 	if (mm_ret != MM_ERROR_NONE) {
 		GST_ERROR("mm_util_resize_image failed 0x%x", ret);
 		free(dst_tmp_data);
@@ -1751,7 +1725,7 @@ gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsign
 	switch (src_format) {
 	case MM_PIXEL_FORMAT_NV12:
 		//jpeg_format = MM_UTIL_JPEG_FMT_NV12;
-		ret_conv = _mmcamcorder_convert_NV12_to_I420(src_data,src_width,src_height,&converted_src,&converted_src_size);
+		ret_conv = _mmcamcorder_convert_NV12_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size);
 		jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
 		break;
 	case MM_PIXEL_FORMAT_NV16:
@@ -1764,12 +1738,12 @@ gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsign
 		break;
 	case MM_PIXEL_FORMAT_YUYV:
 		//jpeg_format = MM_UTIL_JPEG_FMT_YUYV;
-		ret_conv = _mmcamcorder_convert_YUYV_to_I420(src_data,src_width,src_height,&converted_src,&converted_src_size);
+		ret_conv = _mmcamcorder_convert_YUYV_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size);
 		jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
 		break;
 	case MM_PIXEL_FORMAT_UYVY:
 		//jpeg_format = MM_UTIL_JPEG_FMT_UYVY;
-		ret_conv = _mmcamcorder_convert_UYVY_to_I420(src_data,src_width,src_height,&converted_src,&converted_src_size);
+		ret_conv = _mmcamcorder_convert_UYVY_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size);
 		jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
 		break;
 	case MM_PIXEL_FORMAT_I420:
@@ -1811,8 +1785,7 @@ gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsign
 	}
 
 	ret = mm_util_jpeg_encode_to_memory(result_data, (int *)result_length,
-	                                    converted_src, src_width, src_height,
-	                                    jpeg_format, jpeg_quality);
+		converted_src, src_width, src_height, jpeg_format, jpeg_quality);
 
 	if (converted_src && (converted_src != src_data)) {
 		free(converted_src);
@@ -1860,8 +1833,7 @@ gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_
 	jump_width = ratio_width << 1;
 
 	_mmcam_dbg_warn("[src %dx%d] [dst %dx%d] [line width %d] [ratio width %d, height %d]",
-	                src_width, src_height, dst_width, dst_height,
-	                line_width, ratio_width, ratio_height);
+		src_width, src_height, dst_width, dst_height, line_width, ratio_width, ratio_height);
 
 	for (i = 0 ; i < src_height ; i += ratio_height) {
 		line_base = i * line_width;
@@ -1872,11 +1844,11 @@ gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_
 
 			j += jump_width;
 			src_index = line_base + j;
-			if (src_index % 4 == 0) {
+			if (src_index % 4 == 0)
 				result[k++] = src[src_index+2];
-			} else {
+			else
 				result[k++] = src[src_index];
-			}
+
 			result[k++] = src[src_index+1];
 		}
 	}
@@ -1891,17 +1863,17 @@ gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_
 
 static guint16 get_language_code(const char *str)
 {
-    return (guint16) (((str[0]-0x60) & 0x1F) << 10) + (((str[1]-0x60) & 0x1F) << 5) + ((str[2]-0x60) & 0x1F);
+	return (guint16)(((str[0]-0x60) & 0x1F) << 10) + (((str[1]-0x60) & 0x1F) << 5) + ((str[2]-0x60) & 0x1F);
 }
 
 static gchar * str_to_utf8(const gchar *str)
 {
-	return g_convert (str, -1, "UTF-8", "ASCII", NULL, NULL, NULL);
+	return g_convert(str, -1, "UTF-8", "ASCII", NULL, NULL, NULL);
 }
 
 static inline gboolean write_tag(FILE *f, const gchar *tag)
 {
-	while(*tag)
+	while (*tag)
 		FPUTC_CHECK(*tag++, f);
 
 	return TRUE;
@@ -2019,23 +1991,16 @@ _mmcamcorder_convert_YUV_to_RGB888(unsigned char *src, int src_fmt, guint width,
 	int dst_cs = MM_UTIL_IMG_FMT_RGB888;
 	unsigned int dst_size = 0;
 
-	if (src_fmt == COLOR_FORMAT_YUYV)
-	{
+	if (src_fmt == COLOR_FORMAT_YUYV) {
 		_mmcam_dbg_log("Convert YUYV to RGB888\n");
 		src_cs = MM_UTIL_IMG_FMT_YUYV;
-	}
-	else if (src_fmt == COLOR_FORMAT_UYVY)
-	{
+	} else if (src_fmt == COLOR_FORMAT_UYVY) {
 		_mmcam_dbg_log("Convert UYVY to RGB888\n");
 		src_cs = MM_UTIL_IMG_FMT_UYVY;
-	}
-	else if (src_fmt == COLOR_FORMAT_NV12)
-	{
+	} else if (src_fmt == COLOR_FORMAT_NV12) {
 		_mmcam_dbg_log("Convert NV12 to RGB888\n");
 		src_cs = MM_UTIL_IMG_FMT_NV12;
-	}
-	else
-	{
+	} else {
 		_mmcam_dbg_err("NOT supported format [%d]\n", src_fmt);
 		return FALSE;
 	}
@@ -2047,21 +2012,17 @@ _mmcamcorder_convert_YUV_to_RGB888(unsigned char *src, int src_fmt, guint width,
 	}
 
 	*dst = malloc(dst_size);
-	if (*dst == NULL)
-	{
+	if (*dst == NULL) {
 		_mmcam_dbg_err("malloc failed\n");
 		return FALSE;
 	}
 
 	*dst_len = dst_size;
 	ret = mm_util_convert_colorspace(src, width, height, src_cs, *dst, dst_cs);
-	if(ret == 0)
-	{
+	if (ret == 0) {
 		_mmcam_dbg_log("Convert [dst_size:%d] OK.\n", dst_size);
 		return TRUE;
-	}
-	else
-	{
+	} else {
 		free(*dst);
 		*dst = NULL;
 
@@ -2110,11 +2071,10 @@ static gboolean _mmcamcorder_convert_YUYV_to_I420(unsigned char *src, guint widt
 			dst_data[dst_y_offset++] = src[src_offset++]; /*Y*/
 
 			if (i % 2 == 0) {
-				if (j % 4 == 0) {
+				if (j % 4 == 0)
 					dst_data[dst_u_offset++] = src[src_offset++]; /*U*/
-				} else {
+				else
 					dst_data[dst_v_offset++] = src[src_offset++]; /*V*/
-				}
 			} else {
 				src_offset++;
 			}
@@ -2124,8 +2084,7 @@ static gboolean _mmcamcorder_convert_YUYV_to_I420(unsigned char *src, guint widt
 	*dst = dst_data;
 	*dst_len = dst_size;
 
-	_mmcam_dbg_log("DONE: YUVY -> I420 : %dx%d, dst data %p, size %d",
-	                        width, height, *dst, dst_size);
+	_mmcam_dbg_log("DONE: YUVY -> I420 : %dx%d, dst data %p, size %d", width, height, *dst, dst_size);
 
 	return TRUE;
 }
@@ -2167,11 +2126,10 @@ static gboolean _mmcamcorder_convert_UYVY_to_I420(unsigned char *src, guint widt
 	for (i = 0 ; i < height ; i++) {
 		for (j = 0 ; j < loop_length ; j += 2) {
 			if (i % 2 == 0) {
-				if (j % 4 == 0) {
+				if (j % 4 == 0)
 					dst_data[dst_u_offset++] = src[src_offset++]; /*U*/
-				} else {
+				else
 					dst_data[dst_v_offset++] = src[src_offset++]; /*V*/
-				}
 			} else {
 				src_offset++;
 			}
@@ -2183,8 +2141,7 @@ static gboolean _mmcamcorder_convert_UYVY_to_I420(unsigned char *src, guint widt
 	*dst = dst_data;
 	*dst_len = dst_size;
 
-	_mmcam_dbg_log("DONE: UYVY -> I420 : %dx%d, dst data %p, size %d",
-	                        width, height, *dst, dst_size);
+	_mmcam_dbg_log("DONE: UYVY -> I420 : %dx%d, dst data %p, size %d", width, height, *dst, dst_size);
 
 	return TRUE;
 }
@@ -2230,18 +2187,16 @@ static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint widt
 
 	/* set U and V */
 	for (i = 0 ; i < loop_length ; i++) {
-		if (i % 2 == 0) {
+		if (i % 2 == 0)
 			dst_data[dst_u_offset++] = src[src_offset++];
-		} else {
+		else
 			dst_data[dst_v_offset++] = src[src_offset++];
-		}
 	}
 
 	*dst = dst_data;
 	*dst_len = dst_size;
 
-	_mmcam_dbg_log("DONE: NV12 -> I420 : %dx%d, dst data %p, size %d",
-	                        width, height, *dst, dst_size);
+	_mmcam_dbg_log("DONE: NV12 -> I420 : %dx%d, dst data %p, size %d", width, height, *dst, dst_size);
 
 	return TRUE;
 }
diff --git a/src/mm_camcorder_videorec.c b/src/mm_camcorder_videorec.c
index 9013d21..136aa45 100644
--- a/src/mm_camcorder_videorec.c
+++ b/src/mm_camcorder_videorec.c
@@ -20,7 +20,7 @@
  */
 
 /*=======================================================================================
-|  INCLUDE FILES									|
+|  INCLUDE FILES																		|
 =======================================================================================*/
 #include <gst/video/cameracontrol.h>
 #include <gst/app/gstappsrc.h>
@@ -28,22 +28,22 @@
 #include "mm_camcorder_videorec.h"
 
 /*---------------------------------------------------------------------------------------
-|    GLOBAL VARIABLE DEFINITIONS for internal						|
+|    GLOBAL VARIABLE DEFINITIONS for internal											|
 ---------------------------------------------------------------------------------------*/
-#define _MMCAMCORDER_LOCATION_INFO // for add gps information
-#define MAX_ERROR_MESSAGE_LEN         128
+#define _MMCAMCORDER_LOCATION_INFO		/* for add gps information */
+#define MAX_ERROR_MESSAGE_LEN			128
 
 /*---------------------------------------------------------------------------------------
-|    LOCAL VARIABLE DEFINITIONS for internal						|
+|    LOCAL VARIABLE DEFINITIONS for internal											|
 ---------------------------------------------------------------------------------------*/
-#define _MMCAMCORDER_MINIMUM_FRAME              5
-#define _MMCAMCORDER_RETRIAL_COUNT              10
-#define _MMCAMCORDER_FRAME_WAIT_TIME            200000 /* ms */
-#define _OFFSET_COMPOSITION_MATRIX              40L
-#define _GOP_GEN_INTERVAL                       1000000000  /*nano seconds*/
+#define _MMCAMCORDER_MINIMUM_FRAME		5
+#define _MMCAMCORDER_RETRIAL_COUNT		10
+#define _MMCAMCORDER_FRAME_WAIT_TIME	200000	/* ms */
+#define _OFFSET_COMPOSITION_MATRIX		40L
+#define _GOP_GEN_INTERVAL				1000000000	/*nano seconds*/
 
 /*---------------------------------------------------------------------------------------
-|    LOCAL FUNCTION PROTOTYPES:								|
+|    LOCAL FUNCTION PROTOTYPES:															|
 ---------------------------------------------------------------------------------------*/
 /* STATIC INTERNAL FUNCTION */
 static gboolean __mmcamcorder_video_stream_cb(GstElement *element, GstSample *sample, gpointer u_data);
@@ -77,7 +77,7 @@ static gboolean __mmcamcorder_video_stream_cb(GstElement *element, GstSample *sa
 
 	/*
 	_mmcam_dbg_log("ENTER - push_encoding_buffer %d, buffer %p, MALLOCDATA %p, size %d",
-	               sc->info_video->push_encoding_buffer, buffer, GST_BUFFER_MALLOCDATA(buffer), GST_BUFFER_SIZE(buffer));
+		sc->info_video->push_encoding_buffer, buffer, GST_BUFFER_MALLOCDATA(buffer), GST_BUFFER_SIZE(buffer));
 	*/
 
 	/* push buffer in appsrc to encode */
@@ -87,8 +87,8 @@ static gboolean __mmcamcorder_video_stream_cb(GstElement *element, GstSample *sa
 		GstFlowReturn ret = 0;
 		GstClock *pipe_clock = NULL;
 
-		if(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst) {
-			if(sc->info_video->is_firstframe) {
+		if (sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst) {
+			if (sc->info_video->is_firstframe) {
 				sc->info_video->is_firstframe = FALSE;
 				pipe_clock = GST_ELEMENT_CLOCK(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst);
 				if (pipe_clock) {
@@ -98,17 +98,16 @@ static gboolean __mmcamcorder_video_stream_cb(GstElement *element, GstSample *sa
 				}
 			}
 		} else {
-			if(sc->info_video->is_firstframe) {
+			if (sc->info_video->is_firstframe) {
 				sc->info_video->is_firstframe = FALSE;
 				sc->info_video->base_video_ts = GST_BUFFER_PTS(buffer);
 			}
 		}
 
-		GST_BUFFER_PTS(buffer) = GST_BUFFER_PTS (buffer) - sc->info_video->base_video_ts;
+		GST_BUFFER_PTS(buffer) = GST_BUFFER_PTS(buffer) - sc->info_video->base_video_ts;
 
 		ret = gst_app_src_push_buffer((GstAppSrc *)sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, buffer);
-		if (ret != GST_FLOW_OK &&
-		    ret != GST_FLOW_FLUSHING) {
+		if (ret != GST_FLOW_OK && ret != GST_FLOW_FLUSHING) {
 			_mmcam_dbg_err("gst_app_src_push_buffer failed [0x%x]", ret);
 			gst_buffer_unref(buffer);
 			buffer = NULL;
@@ -117,7 +116,7 @@ static gboolean __mmcamcorder_video_stream_cb(GstElement *element, GstSample *sa
 		/*_mmcam_dbg_log("push buffer result : 0x%x", ret);*/
 	} else {
 		_mmcam_dbg_warn("unref video buffer immediately - push encoding buffer %d",
-		                sc->info_video->push_encoding_buffer);
+			sc->info_video->push_encoding_buffer);
 
 		gst_buffer_unref(buffer);
 		buffer = NULL;
@@ -152,14 +151,13 @@ int _mmcamcorder_create_recorder_pipeline(MMHandleType handle)
 	_mmcam_dbg_warn("start");
 
 	err = _mmcamcorder_check_videocodec_fileformat_compatibility(handle);
-	if (err != MM_ERROR_NONE) {
+	if (err != MM_ERROR_NONE)
 		return err;
-	}
 
 	/* Main pipeline */
-	if(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst) {
+	if (sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst) {
 		_mmcam_dbg_log("pipeline is exist so need to remove pipeline _MMCAMCORDER_ENCODE_MAIN_PIPE = %p",
-			       sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst);
+			sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst);
 		_mmcamcorder_remove_recorder_pipeline((MMHandleType)hcamcorder);
 	}
 
@@ -167,41 +165,39 @@ int _mmcamcorder_create_recorder_pipeline(MMHandleType handle)
 
 	/* get audio disable */
 	mm_camcorder_get_attributes(handle, NULL,
-	                            MMCAM_AUDIO_DISABLE, &audio_disable,
-	                            NULL);
+		MMCAM_AUDIO_DISABLE, &audio_disable,
+		NULL);
 
-	if (sc->is_modified_rate || audio_disable) {
+	if (sc->is_modified_rate || audio_disable)
 		sc->audio_disable = TRUE;
-	} else {
+	else
 		sc->audio_disable = FALSE;
-	}
+
 	_mmcam_dbg_log("AUDIO DISABLE : %d (is_modified_rate %d, audio_disable %d)",
-	               sc->audio_disable, sc->is_modified_rate, audio_disable);
+		sc->audio_disable, sc->is_modified_rate, audio_disable);
 
 	if (sc->audio_disable == FALSE) {
 		/* create audiosrc bin */
 		err = _mmcamcorder_create_audiosrc_bin((MMHandleType)hcamcorder);
-		if (err != MM_ERROR_NONE) {
+		if (err != MM_ERROR_NONE)
 			return err;
-		}
 	}
 
 	err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_VIDEO);
-	if (err != MM_ERROR_NONE) {
+	if (err != MM_ERROR_NONE)
 		return err;
-	}
 
 	if (sc->audio_disable == FALSE) {
 		gst_bin_add(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
-		            sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst);
+			sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst);
 	}
 
 	/* add element and encodesink bin to encode main pipeline */
 	gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
-	                 sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst,
-	                 sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst,
-	                 sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
-	                 NULL);
+		sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst,
+		sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst,
+		sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
+		NULL);
 
 	/* Link each element : appsrc - capsfilter - encodesink bin */
 	srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, "src");
@@ -213,15 +209,15 @@ int _mmcamcorder_create_recorder_pipeline(MMHandleType handle)
 	_MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
 
 	if (sc->audio_disable == FALSE) {
-		srcpad = gst_element_get_static_pad (sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
-		sinkpad = gst_element_get_static_pad (sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
+		srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
+		sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
 		_MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
 	}
 
 	_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-	                              CONFIGURE_CATEGORY_MAIN_RECORD,
-	                              "RecordsinkElement",
-	                              &RecordsinkElement);
+		CONFIGURE_CATEGORY_MAIN_RECORD,
+		"RecordsinkElement",
+		&RecordsinkElement);
 	_mmcamcorder_conf_get_value_element_name(RecordsinkElement, &gst_element_rsink_name);
 
 	/* set data probe function */
@@ -233,21 +229,21 @@ int _mmcamcorder_create_recorder_pipeline(MMHandleType handle)
 	if (sc->audio_disable == FALSE) {
 		sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst, "sink");
 		MMCAMCORDER_ADD_BUFFER_PROBE(sinkpad, _MMCAMCORDER_HANDLER_VIDEOREC,
-		                             __mmcamcorder_audioque_dataprobe, hcamcorder);
+			__mmcamcorder_audioque_dataprobe, hcamcorder);
 		gst_object_unref(sinkpad);
 		sinkpad = NULL;
 
 		/* for voice mute */
 		srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, "src");
 		MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_VIDEOREC,
-		                             __mmcamcorder_audio_dataprobe_audio_mute, hcamcorder);
+			__mmcamcorder_audio_dataprobe_audio_mute, hcamcorder);
 		gst_object_unref(srcpad);
 		srcpad = NULL;
 
 		if (sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst) {
 			srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst, "src");
 			MMCAMCORDER_ADD_EVENT_PROBE(srcpad, _MMCAMCORDER_HANDLER_VIDEOREC,
-			                            __mmcamcorder_eventprobe_monitor, hcamcorder);
+				__mmcamcorder_eventprobe_monitor, hcamcorder);
 			gst_object_unref(srcpad);
 			srcpad = NULL;
 		}
@@ -256,7 +252,7 @@ int _mmcamcorder_create_recorder_pipeline(MMHandleType handle)
 	if (sc->encode_element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst) {
 		srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst, "src");
 		MMCAMCORDER_ADD_EVENT_PROBE(srcpad, _MMCAMCORDER_HANDLER_VIDEOREC,
-		                            __mmcamcorder_eventprobe_monitor, hcamcorder);
+			__mmcamcorder_eventprobe_monitor, hcamcorder);
 		gst_object_unref(srcpad);
 		srcpad = NULL;
 	}
@@ -264,7 +260,7 @@ int _mmcamcorder_create_recorder_pipeline(MMHandleType handle)
 	if (sc->audio_disable) {
 		sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst, "sink");
 		MMCAMCORDER_ADD_BUFFER_PROBE(sinkpad, _MMCAMCORDER_HANDLER_VIDEOREC,
-		                             __mmcamcorder_video_dataprobe_audio_disable, hcamcorder);
+			__mmcamcorder_video_dataprobe_audio_disable, hcamcorder);
 		gst_object_unref(sinkpad);
 		sinkpad = NULL;
 	}
@@ -272,13 +268,13 @@ int _mmcamcorder_create_recorder_pipeline(MMHandleType handle)
 	if (!strcmp(gst_element_rsink_name, "filesink")) {
 		srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst, "src");
 		MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_VIDEOREC,
-		                             __mmcamcorder_video_dataprobe_record, hcamcorder);
+			__mmcamcorder_video_dataprobe_record, hcamcorder);
 		gst_object_unref(srcpad);
 		srcpad = NULL;
 
 		srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst, "src");
 		MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_VIDEOREC,
-		                             __mmcamcorder_audio_dataprobe_check, hcamcorder);
+			__mmcamcorder_audio_dataprobe_check, hcamcorder);
 		gst_object_unref(srcpad);
 		srcpad = NULL;
 	}
@@ -297,9 +293,9 @@ int _mmcamcorder_create_recorder_pipeline(MMHandleType handle)
 	return MM_ERROR_NONE;
 
 pipeline_creation_error:
-	for (i = _MMCAMCORDER_AUDIOSRC_BIN ; i <= _MMCAMCORDER_ENCSINK_SINK ; i++) {
+	for (i = _MMCAMCORDER_AUDIOSRC_BIN ; i <= _MMCAMCORDER_ENCSINK_SINK ; i++)
 		_MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, i);
-	}
+
 	_MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE);
 	return err;
 }
@@ -327,7 +323,7 @@ int _mmcamcorder_remove_audio_pipeline(MMHandleType handle)
 
 		/* release audiosrc bin */
 		gst_bin_remove(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
-		               sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst);
+			sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst);
 
 		/*
 			To avoid conflicting between old elements and newly created elements,
@@ -387,7 +383,8 @@ int _mmcamcorder_remove_encode_pipeline(MMHandleType handle)
 			It's because the pipeline of audio recording destroys at the same time,
 			and '_mmcamcorder_element_release_noti' will perfom removing handle.
 		*/
-		//_mmcamcorder_remove_element_handle(handle, (void *)sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE, _MMCAMCORDER_ENCSINK_SINK);
+		/* _mmcamcorder_remove_element_handle(handle, (void *)sc->encode_element,
+			_MMCAMCORDER_ENCODE_MAIN_PIPE, _MMCAMCORDER_ENCSINK_SINK); */
 
 		_mmcam_dbg_log("Encoder pipeline removed");
 	}
@@ -518,22 +515,22 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 			info->record_dual_stream = FALSE;
 
 			ret = mm_camcorder_get_attributes(handle, &err_name,
-			                                  MMCAM_CAMERA_FPS, &fps,
-			                                  MMCAM_CAMERA_WIDTH, &(info->preview_width),
-			                                  MMCAM_CAMERA_HEIGHT, &(info->preview_height),
-			                                  MMCAM_VIDEO_WIDTH, &(info->video_width),
-			                                  MMCAM_VIDEO_HEIGHT, &(info->video_height),
-			                                  MMCAM_FILE_FORMAT, &fileformat,
-			                                  MMCAM_TARGET_FILENAME, &temp_filename, &size,
-			                                  MMCAM_TARGET_MAX_SIZE, &imax_size,
-			                                  MMCAM_TARGET_TIME_LIMIT, &imax_time,
-			                                  MMCAM_FILE_FORMAT, &(info->fileformat),
-			                                  MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
-			                                  MMCAM_ROOT_DIRECTORY, &hcamcorder->root_directory, &root_directory_length,
-			                                  NULL);
+				MMCAM_CAMERA_FPS, &fps,
+				MMCAM_CAMERA_WIDTH, &(info->preview_width),
+				MMCAM_CAMERA_HEIGHT, &(info->preview_height),
+				MMCAM_VIDEO_WIDTH, &(info->video_width),
+				MMCAM_VIDEO_HEIGHT, &(info->video_height),
+				MMCAM_FILE_FORMAT, &fileformat,
+				MMCAM_TARGET_FILENAME, &temp_filename, &size,
+				MMCAM_TARGET_MAX_SIZE, &imax_size,
+				MMCAM_TARGET_TIME_LIMIT, &imax_time,
+				MMCAM_FILE_FORMAT, &(info->fileformat),
+				MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
+				MMCAM_ROOT_DIRECTORY, &hcamcorder->root_directory, &root_directory_length,
+				NULL);
 			if (ret != MM_ERROR_NONE) {
 				_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret);
-				SAFE_FREE (err_name);
+				SAFE_FREE(err_name);
 				goto _ERR_CAMCORDER_VIDEO_COMMAND;
 			}
 
@@ -544,18 +541,16 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 			}
 
 			/* set max size */
-			if (imax_size <= 0) {
+			if (imax_size <= 0)
 				info->max_size = 0; /* do not check */
-			} else {
+			else
 				info->max_size = ((guint64)imax_size) << 10; /* to byte */
-			}
 
 			/* set max time */
-			if (imax_time <= 0) {
+			if (imax_time <= 0)
 				info->max_time = 0; /* do not check */
-			} else {
+			else
 				info->max_time = ((guint64)imax_time) * 1000; /* to millisecond */
-			}
 
 			dir_name = g_path_get_dirname(temp_filename);
 			if (dir_name) {
@@ -568,11 +563,11 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 					if (file_system_type == MSDOS_SUPER_MAGIC &&
 					    (info->max_size == 0 || info->max_size > FAT32_FILE_SYSTEM_MAX_SIZE)) {
 						_mmcam_dbg_warn("FAT32 and too large max[%"G_GUINT64_FORMAT"], set max as %"G_GUINT64_FORMAT,
-						                info->max_size, FAT32_FILE_SYSTEM_MAX_SIZE);
+							info->max_size, FAT32_FILE_SYSTEM_MAX_SIZE);
 						info->max_size = FAT32_FILE_SYSTEM_MAX_SIZE;
 					} else {
 						_mmcam_dbg_warn("file system 0x%x, max size %"G_GUINT64_FORMAT,
-						                file_system_type, info->max_size);
+							file_system_type, info->max_size);
 					}
 				} else {
 					_mmcam_dbg_warn("_mmcamcorder_get_file_system_type failed");
@@ -587,7 +582,7 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 
 			if ((ret_free_space == -1) || free_space <= (_MMCAMCORDER_MINIMUM_SPACE<<1)) {
 				_mmcam_dbg_err("OUT of STORAGE [ret_free_space:%d or free space [%" G_GUINT64_FORMAT "] is smaller than [%d]",
-				               ret_free_space, free_space, (_MMCAMCORDER_MINIMUM_SPACE<<1));
+					ret_free_space, free_space, (_MMCAMCORDER_MINIMUM_SPACE<<1));
 				return MM_ERROR_OUT_OF_STORAGE;
 			}
 
@@ -603,7 +598,7 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 
 			if (info->video_width == 0 || info->video_height == 0) {
 				_mmcam_dbg_warn("video size is invalid [%dx%d] use preview size [%dx%d]",
-				                info->video_width, info->video_height, info->preview_width, info->preview_height);
+					info->video_width, info->video_height, info->preview_width, info->preview_height);
 				info->video_width = info->preview_width;
 				info->video_height = info->preview_height;
 			}
@@ -619,8 +614,8 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 				MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "video-width", info->video_width);
 				MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "video-height", info->video_height);
 			} else if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264 &&
-			           info->preview_width == info->video_width &&
-			           info->preview_height == info->video_height) {
+				info->preview_width == info->video_width &&
+				info->preview_height == info->video_height) {
 				_mmcam_dbg_log("H264 preview mode and same resolution");
 
 				/* No need to restart preview */
@@ -652,9 +647,8 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 				MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
 				MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
 
-				if (ret != MM_ERROR_NONE) {
+				if (ret != MM_ERROR_NONE)
 					goto _ERR_CAMCORDER_VIDEO_COMMAND;
-				}
 
 				if (!_mmcamcorder_set_camera_resolution(handle, info->video_width, info->video_height)) {
 					ret = MM_ERROR_CAMCORDER_INTERNAL;
@@ -663,9 +657,8 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 
 				/* Start preview again with new setting */
 				ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
-				if (ret != MM_ERROR_NONE) {
+				if (ret != MM_ERROR_NONE)
 					goto _ERR_CAMCORDER_VIDEO_COMMAND;
-				}
 
 				if (motion_rate < 1.0) {
 					_mmcam_dbg_warn("wait for stabilization of frame");
@@ -676,28 +669,27 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 			}
 
 			_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
-			                                CONFIGURE_CATEGORY_MAIN_RECORD,
-			                                "DropVideoFrame",
-			                                &(sc->drop_vframe));
+				CONFIGURE_CATEGORY_MAIN_RECORD,
+				"DropVideoFrame",
+				&(sc->drop_vframe));
 
 			_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
-			                                CONFIGURE_CATEGORY_MAIN_RECORD,
-			                                "PassFirstVideoFrame",
-			                                &(sc->pass_first_vframe));
+				CONFIGURE_CATEGORY_MAIN_RECORD,
+				"PassFirstVideoFrame",
+				&(sc->pass_first_vframe));
 
 			_mmcam_dbg_log("Drop video frame count[%d], Pass fisrt video frame count[%d]",
-			               sc->drop_vframe, sc->pass_first_vframe);
+				sc->drop_vframe, sc->pass_first_vframe);
 
 			info->record_drop_count = (guint)motion_rate;
 			info->record_motion_rate = motion_rate;
-			if (sc->is_modified_rate) {
+			if (sc->is_modified_rate)
 				info->record_timestamp_ratio = (_MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE/motion_rate);
-			} else {
+			else
 				info->record_timestamp_ratio = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
-			}
 
 			_mmcam_dbg_warn("recording fps %d, motion rate %f, timestamp_ratio %f",
-			               fps, info->record_motion_rate, info->record_timestamp_ratio);
+				fps, info->record_motion_rate, info->record_timestamp_ratio);
 
 			/* set push buffer flag */
 			info->push_encoding_buffer = PUSH_ENCODING_BUFFER_INIT;
@@ -706,9 +698,8 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 			/* connect video stream cb signal */
 			/*130826 Connect video stream cb for handling fast record frame cb*/
 			if (info->record_dual_stream) {
-				if (_mmcamcorder_connect_video_stream_cb_signal((MMHandleType)hcamcorder) != MM_ERROR_NONE) {
+				if (_mmcamcorder_connect_video_stream_cb_signal((MMHandleType)hcamcorder) != MM_ERROR_NONE)
 					goto _ERR_CAMCORDER_VIDEO_COMMAND;
-				}
 			}
 
 			/* start video stream */
@@ -731,7 +722,7 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 			if (sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst == NULL &&
 			    hcamcorder->task_thread_state == _MMCAMCORDER_TASK_THREAD_STATE_NONE) {
 				/* create encoding pipeline */
-				ret =_mmcamcorder_video_prepare_record((MMHandleType)hcamcorder);
+				ret = _mmcamcorder_video_prepare_record((MMHandleType)hcamcorder);
 				if (ret != MM_ERROR_NONE) {
 					g_mutex_unlock(&hcamcorder->task_thread_lock);
 					goto _ERR_CAMCORDER_VIDEO_COMMAND;
@@ -748,8 +739,10 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 				 basetime wouldn't change if you set (GstClockTime)0.
 				3. Move set start time position below PAUSED of pipeline.
 			*/
-			//gst_element_set_start_time(GST_ELEMENT(sc->element[_MMCAMCORDER_MAIN_PIPE].gst), (GstClockTime)1);
-			//gst_element_set_start_time(GST_ELEMENT(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst), (GstClockTime)1);
+			/*
+			gst_element_set_start_time(GST_ELEMENT(sc->element[_MMCAMCORDER_MAIN_PIPE].gst), (GstClockTime)1);
+			gst_element_set_start_time(GST_ELEMENT(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst), (GstClockTime)1);
+			*/
 
 			info->video_frame_count = 0;
 			info->is_firstframe = TRUE;
@@ -796,18 +789,17 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 						CameraControlChannel = item->data;
 						_mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label);
 						if (!strcmp(CameraControlChannel->label, "new-gop")) {
-							//gst_camera_control_set_value(CameraControl, CameraControlChannel, 1);
+							/* gst_camera_control_set_value(CameraControl, CameraControlChannel, 1); */
 							break;
 						}
 					}
 
-					if (item == NULL) {
+					if (item == NULL)
 						_mmcam_dbg_warn("failed to find new-gop control channel");
-					}
 				}
 			} else {
 				_mmcam_dbg_warn("Can't cast Video source into camera control or not H264 prevew format[%d]",
-				                sc->info_image->preview_format);
+					sc->info_image->preview_format);
 			}
 		} else {
 			/* Resume case */
@@ -822,14 +814,13 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 						CameraControlChannel = item->data;
 						_mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label);
 						if (!strcmp(CameraControlChannel->label, "new-gop")) {
-							//gst_camera_control_set_value(CameraControl, CameraControlChannel, 1);
+							/* gst_camera_control_set_value(CameraControl, CameraControlChannel, 1); */
 							break;
 						}
 					}
 
-					if (item == NULL) {
+					if (item == NULL)
 						_mmcam_dbg_warn("failed to find new-gop control channel");
-					}
 				}
 			}
 
@@ -852,12 +843,10 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 				if (info->video_frame_count >= _MMCAMCORDER_MINIMUM_FRAME) {
 					break;
 				} else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
-					_mmcam_dbg_err("Pause fail, frame count %llu",
-					               info->video_frame_count);
+					_mmcam_dbg_err("Pause fail, frame count %llu", info->video_frame_count);
 					return MM_ERROR_CAMCORDER_INVALID_CONDITION;
 				} else {
-					_mmcam_dbg_warn("Waiting for enough video frame, retrial[%d], frame %llu",
-					                count, info->video_frame_count);
+					_mmcam_dbg_warn("Waiting for enough video frame, retrial[%d], frame %llu", count, info->video_frame_count);
 				}
 
 				usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
@@ -867,11 +856,11 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 					break;
 				} else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
 					_mmcam_dbg_err("Pause fail, frame count VIDEO[%llu], AUDIO [%llu]",
-					               info->video_frame_count, info->audio_frame_count);
+						info->video_frame_count, info->audio_frame_count);
 					return MM_ERROR_CAMCORDER_INVALID_CONDITION;
 				} else {
 					_mmcam_dbg_warn("Waiting for enough frames, retrial [%d], VIDEO[%llu], AUDIO [%llu]",
-					                count, info->video_frame_count, info->audio_frame_count);
+						count, info->video_frame_count, info->audio_frame_count);
 				}
 
 				usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
@@ -908,9 +897,8 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 		info->push_encoding_buffer = PUSH_ENCODING_BUFFER_STOP;
 
 		ret = _mmcamcorder_remove_recorder_pipeline((MMHandleType)hcamcorder);
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			goto _ERR_CAMCORDER_VIDEO_COMMAND;
-		}
 
 		/* set recording hint */
 		MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "recording-hint", FALSE);
@@ -935,7 +923,7 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 			MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
 			MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
 
-			ret =_mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
+			ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
 
 			/* check decoder recreation */
 			if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) {
@@ -946,9 +934,8 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 			MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
 			MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
 
-			if (ret != MM_ERROR_NONE) {
+			if (ret != MM_ERROR_NONE)
 				goto _ERR_CAMCORDER_VIDEO_COMMAND;
-			}
 
 			/* reset restart_preview for inset window layout */
 			info->restart_preview = FALSE;
@@ -958,10 +945,9 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 				goto _ERR_CAMCORDER_VIDEO_COMMAND;
 			}
 
-			ret =_mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
-			if (ret != MM_ERROR_NONE) {
+			ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
+			if (ret != MM_ERROR_NONE)
 				goto _ERR_CAMCORDER_VIDEO_COMMAND;
-			}
 		}
 
 		/* remove target file */
@@ -1000,7 +986,7 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 					break;
 				} else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
 					_mmcam_dbg_err("Commit fail, frame count is %llu, capturing %d",
-					               info->video_frame_count, hcamcorder->capture_in_recording);
+						info->video_frame_count, hcamcorder->capture_in_recording);
 
 					if (info->video_frame_count >= _MMCAMCORDER_MINIMUM_FRAME) {
 						_mmcam_dbg_warn("video frames are enough. keep going...");
@@ -1010,7 +996,7 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 					}
 				} else {
 					_mmcam_dbg_warn("Waiting for enough video frame, retrial [%d], frame %llu, capturing %d",
-					                count, info->video_frame_count, hcamcorder->capture_in_recording);
+						count, info->video_frame_count, hcamcorder->capture_in_recording);
 				}
 			} else {
 				/* check both of video and audio frame */
@@ -1020,7 +1006,7 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 					break;
 				} else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
 					_mmcam_dbg_err("Commit fail, VIDEO[%llu], AUDIO [%llu], capturing %d",
-					               info->video_frame_count, info->audio_frame_count, hcamcorder->capture_in_recording);
+						info->video_frame_count, info->audio_frame_count, hcamcorder->capture_in_recording);
 
 					if (info->video_frame_count >= _MMCAMCORDER_MINIMUM_FRAME && info->audio_frame_count) {
 						_mmcam_dbg_warn("video/audio frames are enough. keep going...");
@@ -1032,7 +1018,7 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 					return MM_ERROR_CAMCORDER_INVALID_CONDITION;
 				} else {
 					_mmcam_dbg_warn("Waiting for enough frames, retrial [%d], VIDEO[%llu], AUDIO [%llu], capturing %d",
-					                count, info->video_frame_count, info->audio_frame_count, hcamcorder->capture_in_recording);
+						count, info->video_frame_count, info->audio_frame_count, hcamcorder->capture_in_recording);
 				}
 			}
 
@@ -1087,7 +1073,7 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 
 		/* Wait EOS */
 		_mmcam_dbg_log("Start to wait EOS");
-		ret =_mmcamcorder_get_eos_message(handle);
+		ret = _mmcamcorder_get_eos_message(handle);
 		if (ret != MM_ERROR_NONE) {
 			info->b_commiting = FALSE;
 			goto _ERR_CAMCORDER_VIDEO_COMMAND;
@@ -1105,9 +1091,8 @@ int _mmcamcorder_video_command(MMHandleType handle, int command)
 	return MM_ERROR_NONE;
 
 _ERR_CAMCORDER_VIDEO_COMMAND:
-	if (command == _MMCamcorder_CMD_RECORD) {
+	if (command == _MMCamcorder_CMD_RECORD)
 		_mmcamcorder_remove_recorder_pipeline((MMHandleType)hcamcorder);
-	}
 
 	return ret;
 }
@@ -1152,13 +1137,12 @@ int _mmcamcorder_video_handle_eos(MMHandleType handle)
 	MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
 
 	mm_camcorder_get_attributes(handle, NULL,
-	                            MMCAM_RECORDER_TAG_ENABLE, &enabletag,
-	                            NULL);
+		MMCAM_RECORDER_TAG_ENABLE, &enabletag,
+		NULL);
 
 	ret = _mmcamcorder_remove_recorder_pipeline((MMHandleType)hcamcorder);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		_mmcam_dbg_warn("_MMCamcorder_CMD_COMMIT:__mmcamcorder_remove_recorder_pipeline failed. error[%x]", ret);
-	}
 
 	/* set recording hint */
 	MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "recording-hint", FALSE);
@@ -1191,7 +1175,7 @@ int _mmcamcorder_video_handle_eos(MMHandleType handle)
 	if (info->max_size > 0) {
 		_mmcamcorder_get_file_size(info->filename, &file_size);
 		_mmcam_dbg_log("MAX size %lld byte - created filesize %lld byte",
-		               info->max_size, file_size);
+					   info->max_size, file_size);
 
 		if (file_size > info->max_size) {
 			_MMCamcorderMsgItem message;
@@ -1232,7 +1216,7 @@ int _mmcamcorder_video_handle_eos(MMHandleType handle)
 		/* recover preview size */
 		_mmcamcorder_set_camera_resolution(handle, info->preview_width, info->preview_height);
 
-		ret =_mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
+		ret = _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
 		/* Do not return when error is occurred.
 		   Recording file was created successfully, but starting pipeline failed */
 		if (ret != MM_ERROR_NONE) {
@@ -1252,7 +1236,7 @@ int _mmcamcorder_video_handle_eos(MMHandleType handle)
 		_mmcam_dbg_err("Recording report fail(%s). Out of memory.", info->filename);
 	} else {
 		report->recording_filename = g_strdup(info->filename);
-		msg.param.data= report;
+		msg.param.data = report;
 		msg.param.code = 1;
 		_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 	}
@@ -1292,7 +1276,8 @@ int _mmcamcorder_video_handle_eos(MMHandleType handle)
  * @remarks
  * @see
  */
-static GstPadProbeReturn __mmcamcorder_eventprobe_monitor(GstPad *pad, GstPadProbeInfo *info, gpointer u_data){
+static GstPadProbeReturn __mmcamcorder_eventprobe_monitor(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
+{
 	GstEvent *event = GST_PAD_PROBE_INFO_EVENT(info);
 	switch (GST_EVENT_TYPE(event)) {
 	case GST_EVENT_UNKNOWN:
@@ -1302,7 +1287,7 @@ static GstPadProbeReturn __mmcamcorder_eventprobe_monitor(GstPad *pad, GstPadPro
 	case GST_EVENT_NAVIGATION:
 	case GST_EVENT_LATENCY:
 	/* downstream serialized events */
-	case GST_EVENT_SEGMENT :
+	case GST_EVENT_SEGMENT:
 	case GST_EVENT_TAG:
 	case GST_EVENT_BUFFERSIZE:
 		_mmcam_dbg_log("[%s:%s] gots %s", GST_DEBUG_PAD_NAME(pad), GST_EVENT_TYPE_NAME(event));
@@ -1334,6 +1319,7 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_check(GstPad *pad, GstPad
 	_MMCamcorderMsgItem msg;
 	guint64 buffer_size = 0;
 	guint64 trailer_size = 0;
+	guint64 max_size = 0;
 
 	mmf_return_val_if_fail(hcamcorder, GST_PAD_PROBE_OK);
 	mmf_return_val_if_fail(buffer, GST_PAD_PROBE_DROP);
@@ -1376,21 +1362,20 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_check(GstPad *pad, GstPad
 	}
 
 	/* check max size of recorded file */
-	if (videoinfo->max_size > 0 &&
-	    videoinfo->max_size < videoinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE) {
+	max_size = videoinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE;
+	if (videoinfo->max_size > 0 && videoinfo->max_size < max_size) {
 		GstState pipeline_state = GST_STATE_VOID_PENDING;
 		GstElement *pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
 		_mmcam_dbg_warn("Max size!!! Recording is paused.");
 		_mmcam_dbg_warn("Max size : [%" G_GUINT64_FORMAT "], current file size : [%" G_GUINT64_FORMAT "]," \
-		                " buffer size : [%" G_GUINT64_FORMAT "], trailer size : [%" G_GUINT64_FORMAT "]",
-		                videoinfo->max_size, videoinfo->filesize, buffer_size, trailer_size);
+			" buffer size : [%" G_GUINT64_FORMAT "], trailer size : [%" G_GUINT64_FORMAT "]",
+			videoinfo->max_size, videoinfo->filesize, buffer_size, trailer_size);
 
 		if (!sc->isMaxsizePausing) {
 			sc->isMaxsizePausing = TRUE;
 			gst_element_get_state(pipeline, &pipeline_state, NULL, -1) ;
-			if (pipeline_state == GST_STATE_PLAYING) {
+			if (pipeline_state == GST_STATE_PLAYING)
 				MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
-			}
 
 			msg.id = MM_MESSAGE_CAMCORDER_MAX_SIZE;
 			_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
@@ -1419,6 +1404,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_record(GstPad *pad, GstPa
 	guint64 buffer_size = 0;
 	guint64 trailer_size = 0;
 	guint64 queued_buffer = 0;
+	guint64 max_size = 0;
 	char *dir_name = NULL;
 	GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER(info);
 	GstMapInfo mapinfo;
@@ -1448,7 +1434,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_record(GstPad *pad, GstPa
 	videoinfo->video_frame_count++;
 	if (videoinfo->video_frame_count <= (guint64)_MMCAMCORDER_MINIMUM_FRAME) {
 		/* _mmcam_dbg_log("Pass minimum frame: info->video_frame_count: %" G_GUINT64_FORMAT " ",
-		                info->video_frame_count); */
+			info->video_frame_count); */
 		g_mutex_lock(&videoinfo->size_check_lock);
 		videoinfo->filesize += buffer_size;
 		g_mutex_unlock(&videoinfo->size_check_lock);
@@ -1481,11 +1467,11 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_record(GstPad *pad, GstPa
 		if (sc->ferror_count == 2 && sc->ferror_send == FALSE) {
 			sc->ferror_send = TRUE;
 			msg.id = MM_MESSAGE_CAMCORDER_ERROR;
-			if (ret == -2) {
+			if (ret == -2)
 				msg.param.code = MM_ERROR_FILE_NOT_FOUND;
-			} else {
+			else
 				msg.param.code = MM_ERROR_FILE_READ;
-			}
+
 			_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 		} else {
 			sc->ferror_count++;
@@ -1499,6 +1485,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_record(GstPad *pad, GstPa
 		if (sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst) {
 			MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst, "current-level-bytes", &aq_size);
 		}
+
 		if (sc->encode_element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst) {
 			MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst, "current-level-bytes", &vq_size);
 		}
@@ -1509,8 +1496,8 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_record(GstPad *pad, GstPa
 		if (free_space < (_MMCAMCORDER_MINIMUM_SPACE + buffer_size + trailer_size + queued_buffer)) {
 			_mmcam_dbg_warn("No more space for recording!!! Recording is paused.");
 			_mmcam_dbg_warn("Free Space : [%" G_GUINT64_FORMAT "], trailer size : [%" G_GUINT64_FORMAT "]," \
-			                " buffer size : [%" G_GUINT64_FORMAT "], queued buffer size : [%" G_GUINT64_FORMAT "]", \
-			                free_space, trailer_size, buffer_size, queued_buffer);
+				" buffer size : [%" G_GUINT64_FORMAT "], queued buffer size : [%" G_GUINT64_FORMAT "]", \
+				free_space, trailer_size, buffer_size, queued_buffer);
 
 			if (!sc->isMaxsizePausing) {
 				MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
@@ -1528,21 +1515,20 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_record(GstPad *pad, GstPa
 	g_mutex_lock(&videoinfo->size_check_lock);
 
 	/* check max size of recorded file */
-	if (videoinfo->max_size > 0 &&
-	    videoinfo->max_size < videoinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE) {
+	max_size = videoinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE;
+	if (videoinfo->max_size > 0 && videoinfo->max_size < max_size) {
 		GstState pipeline_state = GST_STATE_VOID_PENDING;
 		GstElement *pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
 		_mmcam_dbg_warn("Max size!!! Recording is paused.");
 		_mmcam_dbg_warn("Max size : [%" G_GUINT64_FORMAT "], current file size : [%" G_GUINT64_FORMAT "]," \
-		                " buffer size : [%" G_GUINT64_FORMAT "], trailer size : [%" G_GUINT64_FORMAT "]",
-						videoinfo->max_size, videoinfo->filesize, buffer_size, trailer_size);
+			" buffer size : [%" G_GUINT64_FORMAT "], trailer size : [%" G_GUINT64_FORMAT "]",
+			videoinfo->max_size, videoinfo->filesize, buffer_size, trailer_size);
 
 		if (!sc->isMaxsizePausing) {
 			sc->isMaxsizePausing = TRUE;
 			gst_element_get_state(pipeline, &pipeline_state, NULL, -1) ;
-			if (pipeline_state == GST_STATE_PLAYING) {
+			if (pipeline_state == GST_STATE_PLAYING)
 				MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
-			}
 
 			msg.id = MM_MESSAGE_CAMCORDER_MAX_SIZE;
 			_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
@@ -1602,7 +1588,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_audio_disable(GstPad *pad
 	/* check max time */
 	if (videoinfo->max_time > 0 && rec_pipe_time > videoinfo->max_time) {
 		_mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
-		                rec_pipe_time, videoinfo->max_time);
+			rec_pipe_time, videoinfo->max_time);
 
 		if (!sc->isMaxtimePausing) {
 			MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
@@ -1640,7 +1626,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_audio_disable(GstPad *pad
 
 	/*
 	_mmcam_dbg_log("time [%" GST_TIME_FORMAT "], size [%d]",
-	               GST_TIME_ARGS(rec_pipe_time), msg.param.recording_status.filesize);
+		GST_TIME_ARGS(rec_pipe_time), msg.param.recording_status.filesize);
 	*/
 
 	if (videoinfo->record_timestamp_ratio != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
@@ -1648,7 +1634,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_audio_disable(GstPad *pad
 
 		/*
 		_mmcam_dbg_log("record_motion_rate %d, videoinfo->record_drop_count %d",
-		               record_motion_rate, videoinfo->record_drop_count);
+			record_motion_rate, videoinfo->record_drop_count);
 		*/
 
 		/* drop some frame if fast motion */
@@ -1695,7 +1681,7 @@ static GstPadProbeReturn __mmcamcorder_audioque_dataprobe(GstPad *pad, GstPadPro
 	videoinfo = sc->info_video;
 
 	if (!GST_CLOCK_TIME_IS_VALID(GST_BUFFER_PTS(buffer))) {
-		_mmcam_dbg_err( "Buffer timestamp is invalid, check it");
+		_mmcam_dbg_err("Buffer timestamp is invalid, check it");
 		return GST_PAD_PROBE_OK;
 	}
 
@@ -1719,7 +1705,7 @@ static GstPadProbeReturn __mmcamcorder_audioque_dataprobe(GstPad *pad, GstPadPro
 
 	if (videoinfo->max_time > 0 && rec_pipe_time > videoinfo->max_time) {
 		_mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
-		                rec_pipe_time, videoinfo->max_time);
+			rec_pipe_time, videoinfo->max_time);
 
 		if (!sc->isMaxtimePausing) {
 			MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
@@ -1747,7 +1733,7 @@ static GstPadProbeReturn __mmcamcorder_audioque_dataprobe(GstPad *pad, GstPadPro
 
 	/*
 	_mmcam_dbg_log("audio data probe :: time [%" GST_TIME_FORMAT "], size [%lld KB]",
-	               GST_TIME_ARGS(rec_pipe_time), msg.param.recording_status.filesize);
+		GST_TIME_ARGS(rec_pipe_time), msg.param.recording_status.filesize);
 	*/
 
 	return GST_PAD_PROBE_OK;
@@ -1770,10 +1756,10 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_audio_mute(GstPad *pad, G
 
 	/*_mmcam_dbg_log("AUDIO SRC time stamp : [%" GST_TIME_FORMAT "] \n", GST_TIME_ARGS(GST_BUFFER_PTS(buffer)));*/
 	err = mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_name,
-	                                  MMCAM_AUDIO_VOLUME, &volume,
-	                                  MMCAM_AUDIO_FORMAT, &format,
-	                                  MMCAM_AUDIO_CHANNEL, &channel,
-	                                  NULL);
+		MMCAM_AUDIO_VOLUME, &volume,
+		MMCAM_AUDIO_FORMAT, &format,
+		MMCAM_AUDIO_CHANNEL, &channel,
+		NULL);
 	if (err != MM_ERROR_NONE) {
 		_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
 		SAFE_FREE(err_name);
@@ -1785,9 +1771,8 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_audio_mute(GstPad *pad, G
 	gst_buffer_map(buffer, &mapinfo, GST_MAP_READWRITE);
 
 	/* Set audio stream NULL */
-	if (volume == 0.0) {
+	if (volume == 0.0)
 		memset(mapinfo.data, 0, mapinfo.size);
-	}
 
 	/* CALL audio stream callback */
 	if (hcamcorder->astream_cb && buffer && mapinfo.data && mapinfo.size > 0) {
@@ -1800,7 +1785,7 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_audio_mute(GstPad *pad, G
 		}
 
 		/*_mmcam_dbg_log("Call video steramCb, data[%p], Width[%d],Height[%d], Format[%d]",
-		               GST_BUFFER_DATA(buffer), width, height, format);*/
+			GST_BUFFER_DATA(buffer), width, height, format);*/
 
 		stream.data = (void *)mapinfo.data;
 		stream.format = format;
@@ -1810,9 +1795,8 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_audio_mute(GstPad *pad, G
 
 		_MMCAMCORDER_LOCK_ASTREAM_CALLBACK(hcamcorder);
 
-		if (hcamcorder->astream_cb) {
+		if (hcamcorder->astream_cb)
 			hcamcorder->astream_cb(&stream, hcamcorder->astream_cb_param);
-		}
 
 		_MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK(hcamcorder);
 	}
@@ -1856,8 +1840,8 @@ static gboolean __mmcamcorder_add_metadata_mp4(MMHandleType handle)
 	int gps_enable = 0;
 	char *err_name = NULL;
 	char err_msg[MAX_ERROR_MESSAGE_LEN] = {'\0',};
-	_MMCamcorderLocationInfo location_info = {0,0,0};
-	_MMCamcorderLocationInfo geo_info = {0,0,0};
+	_MMCamcorderLocationInfo location_info = {0, 0, 0};
+	_MMCamcorderLocationInfo geo_info = {0, 0, 0};
 
 	_MMCamcorderVideoInfo *info = NULL;
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
@@ -1881,15 +1865,15 @@ static gboolean __mmcamcorder_add_metadata_mp4(MMHandleType handle)
 	}
 
 	mm_camcorder_get_attributes(handle, &err_name,
-	                            MMCAM_TAG_LATITUDE, &latitude,
-	                            MMCAM_TAG_LONGITUDE, &longitude,
-	                            MMCAM_TAG_ALTITUDE, &altitude,
-	                            MMCAM_TAG_VIDEO_ORIENTATION, &orientation,
-	                            MMCAM_TAG_GPS_ENABLE, &gps_enable,
-	                            NULL);
+		MMCAM_TAG_LATITUDE, &latitude,
+		MMCAM_TAG_LONGITUDE, &longitude,
+		MMCAM_TAG_ALTITUDE, &altitude,
+		MMCAM_TAG_VIDEO_ORIENTATION, &orientation,
+		MMCAM_TAG_GPS_ENABLE, &gps_enable,
+		NULL);
 	if (err_name) {
 		_mmcam_dbg_warn("Get tag attrs fail. (%s:%x)", err_name, err);
-		SAFE_FREE (err_name);
+		SAFE_FREE(err_name);
 	}
 
 	location_info.longitude = _mmcamcorder_double_to_fix(longitude);
@@ -1901,20 +1885,18 @@ static gboolean __mmcamcorder_add_metadata_mp4(MMHandleType handle)
 	/* find udta container.
 	   if, there are udta container, write loci box after that
 	   else, make udta container and write loci box. */
-	if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('u','d','t','a'), TRUE)) {
+	if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('u', 'd', 't', 'a'), TRUE)) {
 		size_t nread = 0;
 
 		_mmcam_dbg_log("find udta container");
 
 		/* read size */
-		if (fseek(f, -8L, SEEK_CUR) != 0) {
+		if (fseek(f, -8L, SEEK_CUR) != 0)
 			goto fail;
-		}
 
 		udta_pos = ftello(f);
-		if (udta_pos < 0) {
+		if (udta_pos < 0)
 			goto ftell_fail;
-		}
 
 		nread = fread(&buf, sizeof(char), sizeof(buf), f);
 
@@ -1923,9 +1905,8 @@ static gboolean __mmcamcorder_add_metadata_mp4(MMHandleType handle)
 		udta_size = _mmcamcorder_get_container_size(buf);
 
 		/* goto end of udta and write 'loci' box */
-		if (fseek(f, (udta_size-4L), SEEK_CUR) != 0) {
+		if (fseek(f, (udta_size-4L), SEEK_CUR) != 0)
 			goto fail;
-		}
 
 		if (gps_enable) {
 			if (!_mmcamcorder_write_loci(f, location_info)) {
@@ -1940,18 +1921,15 @@ static gboolean __mmcamcorder_add_metadata_mp4(MMHandleType handle)
 		}
 
 		current_pos = ftello(f);
-		if (current_pos < 0) {
+		if (current_pos < 0)
 			goto ftell_fail;
-		}
 
-		if (!_mmcamcorder_update_size(f, udta_pos, current_pos)) {
+		if (!_mmcamcorder_update_size(f, udta_pos, current_pos))
 			goto fail;
-		}
 	} else {
 		_mmcam_dbg_log("No udta container");
-		if (fseek(f, 0, SEEK_END) != 0) {
+		if (fseek(f, 0, SEEK_END) != 0)
 			goto fail;
-		}
 
 		if (!_mmcamcorder_write_udta(f, gps_enable, location_info, geo_info)) {
 			_mmcam_dbg_err("failed to write udta");
@@ -1961,25 +1939,22 @@ static gboolean __mmcamcorder_add_metadata_mp4(MMHandleType handle)
 
 	/* find moov container.
 	   update moov container size. */
-	if((current_pos = ftello(f))<0)
+	if ((current_pos = ftello(f)) < 0)
 		goto ftell_fail;
 
-	if (_mmcamcorder_find_tag(f, MMCAM_FOURCC('m','o','o','v'), TRUE)) {
+	if (_mmcamcorder_find_tag(f, MMCAM_FOURCC('m', 'o', 'o', 'v'), TRUE)) {
 		gint64 internal_pos = ftello(f);
 
 		_mmcam_dbg_log("found moov container");
-		if (fseek(f, -8L, SEEK_CUR) !=0) {
+		if (fseek(f, -8L, SEEK_CUR) != 0)
 			goto fail;
-		}
 
 		moov_pos = ftello(f);
-		if (moov_pos < 0) {
+		if (moov_pos < 0)
 			goto ftell_fail;
-		}
 
-		if (!_mmcamcorder_update_size(f, moov_pos, current_pos)) {
+		if (!_mmcamcorder_update_size(f, moov_pos, current_pos))
 			goto fail;
-		}
 
 		/* add orientation info */
 		if (fseeko(f, internal_pos, SEEK_SET) < 0) {
@@ -1987,12 +1962,12 @@ static gboolean __mmcamcorder_add_metadata_mp4(MMHandleType handle)
 			goto fail;
 		}
 
-		if (!_mmcamcorder_find_tag(f, MMCAM_FOURCC('t','r','a','k'), FALSE)) {
+		if (!_mmcamcorder_find_tag(f, MMCAM_FOURCC('t', 'r', 'a', 'k'), FALSE)) {
 			_mmcam_dbg_err("failed to find [trak] tag");
 			goto fail;
 		}
 
-		if (!_mmcamcorder_find_tag(f, MMCAM_FOURCC('t','k','h','d'), FALSE)) {
+		if (!_mmcamcorder_find_tag(f, MMCAM_FOURCC('t', 'k', 'h', 'd'), FALSE)) {
 			_mmcam_dbg_err("failed to find [tkhd] tag");
 			goto fail;
 		}
@@ -2037,9 +2012,9 @@ int _mmcamcorder_connect_video_stream_cb_signal(MMHandleType handle)
 	if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
 		_mmcam_dbg_warn("connect video stream cb signal to _MMCAMCORDER_VIDEOSRC_SRC");
 		MMCAMCORDER_SIGNAL_CONNECT(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst,
-		                           _MMCAMCORDER_HANDLER_VIDEOREC, "video-stream-cb",
-		                           G_CALLBACK(__mmcamcorder_video_stream_cb),
-		                           hcamcorder);
+			_MMCAMCORDER_HANDLER_VIDEOREC, "video-stream-cb",
+			G_CALLBACK(__mmcamcorder_video_stream_cb),
+			hcamcorder);
 		return MM_ERROR_NONE;
 	} else {
 		_mmcam_dbg_err("videosrc element is not created yet");
@@ -2067,21 +2042,19 @@ int _mmcamcorder_video_prepare_record(MMHandleType handle)
 	_mmcam_dbg_warn("start");
 
 	/* create encoding pipeline */
-	ret =_mmcamcorder_create_recorder_pipeline((MMHandleType)hcamcorder);
-	if (ret != MM_ERROR_NONE) {
+	ret = _mmcamcorder_create_recorder_pipeline((MMHandleType)hcamcorder);
+	if (ret != MM_ERROR_NONE)
 		goto _ERR_PREPARE_RECORD;
-	}
 
 	if (info->filename == NULL) {
 		char *temp_filename = NULL;
 		int size = 0;
 
 		mm_camcorder_get_attributes(handle, NULL,
-		                            MMCAM_TARGET_FILENAME, &temp_filename, &size,
-		                            NULL);
-		if (temp_filename) {
+			MMCAM_TARGET_FILENAME, &temp_filename, &size,
+			NULL);
+		if (temp_filename)
 			info->filename = g_strdup(temp_filename);
-		}
 
 		if (!info->filename) {
 			_mmcam_dbg_err("strdup[src:%p] was failed", temp_filename);
@@ -2099,9 +2072,8 @@ int _mmcamcorder_video_prepare_record(MMHandleType handle)
 	sc->previous_slot_time = 0;
 
 	ret = _mmcamcorder_gst_set_state(handle, sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst, GST_STATE_PAUSED);
-	if (ret != MM_ERROR_NONE) {
+	if (ret != MM_ERROR_NONE)
 		goto _ERR_PREPARE_RECORD;
-	}
 
 	_mmcam_dbg_warn("done");