[0.6.144] resolve decode pad added complexity issuesubmit/tizen/20181109.060212accepted/tizen/unified/20181113.163412

- make fakesink creation function for video and audio exclude path.
- make input-select creation function
- use Macro to get cpas, structure, mimetype from pad.

Change-Id: Ia061628d255918d8a3619566cf013e94c457033f

6 files changed, 327 insertions, 342 deletions

diff --git a/packaging/libmm-player.spec b/packaging/libmm-player.spec
index 91f65b1..47c0fc9 100644
--- a/packaging/libmm-player.spec
+++ b/packaging/libmm-player.spec
@@ -1,6 +1,6 @@
 Name:       libmm-player
 Summary:    Multimedia Framework Player Library
-Version:    0.6.143
+Version:    0.6.144
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0
diff --git a/src/include/mm_player_gst.h b/src/include/mm_player_gst.h
index 598dd63..229462e 100644
--- a/src/include/mm_player_gst.h
+++ b/src/include/mm_player_gst.h
@@ -34,6 +34,23 @@ extern "C"
 {
 #endif
 
+/* get caps info */
+#define MMPLAYER_GST_GET_CAPS_INFO(x_pad, x_caps, x_str, x_name, x_ret) \
+do { \
+	if (!x_caps) \
+		x_caps = gst_pad_query_caps(x_pad, NULL); \
+	if (x_caps) { \
+		x_str = gst_caps_get_structure(x_caps, 0); \
+		if (x_str) { \
+			x_name = gst_structure_get_name(x_str); \
+		} \
+	} \
+	if (!x_caps || !x_str || !x_name) { \
+		LOGE("failed to get caps info"); \
+		x_ret = FALSE; \
+	} \
+} while (0)
+
 /*=======================================================================================
 | GLOBAL FUNCTION PROTOTYPES								|
 ========================================================================================*/
diff --git a/src/include/mm_player_priv.h b/src/include/mm_player_priv.h
index d6bbbe9..dc3e0b6 100644
--- a/src/include/mm_player_priv.h
+++ b/src/include/mm_player_priv.h
@@ -438,7 +438,7 @@ typedef struct {
 } MMPlayerPendingSeek;
 
 typedef struct {
-	GObject* obj;
+	GObject *obj;
 	gulong sig;
 } MMPlayerSignalItem;
 
@@ -505,7 +505,7 @@ typedef struct {
  */
 typedef struct {
 	gboolean used;
-	void* bo;
+	void *bo;
 } mm_player_video_bo_info_t;
 
 typedef struct {
@@ -515,7 +515,7 @@ typedef struct {
 } VariantData;
 
 typedef struct {
-	GList* var_list;
+	GList *var_list;
 	VariantData limit;
 } MMAdaptiveVariantInfo;
 
@@ -560,14 +560,14 @@ typedef struct {
 	GMutex playback_lock;
 
 	/* gapless play thread */
-	GThread* gapless_play_thread;
+	GThread *gapless_play_thread;
 	gboolean gapless_play_thread_exit;
 	GCond gapless_play_thread_cond;
 	GMutex gapless_play_thread_mutex;
 	mm_player_gapless_t gapless;
 
 	/* capture thread */
-	GThread* capture_thread;
+	GThread *capture_thread;
 	gboolean capture_thread_exit;
 	GCond capture_thread_cond;
 	GMutex capture_thread_mutex;
@@ -576,7 +576,7 @@ typedef struct {
 	MMVideoBuffer captured;
 
 	/* gst bus msg thread, create during realize */
-	GThread* bus_msg_thread;
+	GThread *bus_msg_thread;
 	gboolean bus_msg_thread_exit;
 	GCond bus_msg_thread_cond;
 	GMutex bus_msg_thread_mutex;
@@ -592,7 +592,7 @@ typedef struct {
 
 	/* message callback */
 	MMMessageCallback msg_cb;
-	void* msg_cb_param;
+	void *msg_cb_param;
 
 	/* progressive download */
 	mm_player_pd_t *pd_downloader;
@@ -618,8 +618,8 @@ typedef struct {
 	int video_num_buffers;	/* total num of buffers in vcodec */
 	int video_extra_num_buffers; /* extra num of buffers in vcodec */
 
-	void* buffer_cb_user_param[MM_PLAYER_STREAM_TYPE_MAX];
-	void* seek_cb_user_param[MM_PLAYER_STREAM_TYPE_MAX];
+	void *buffer_cb_user_param[MM_PLAYER_STREAM_TYPE_MAX];
+	void *seek_cb_user_param[MM_PLAYER_STREAM_TYPE_MAX];
 
 	/* video stream changed callback */
 	mm_player_stream_changed_callback video_stream_changed_cb;
@@ -631,18 +631,18 @@ typedef struct {
 
 	/* video stream callback */
 	mm_player_video_stream_callback video_stream_cb;
-	void* video_stream_cb_user_param;
+	void *video_stream_cb_user_param;
 	GCond video_bo_cond;
 	GMutex video_bo_mutex;
-	GList* video_bo_list; /* mm_player_video_bo_info_t, bo list for decoded video data by sw codec */
+	GList *video_bo_list; /* mm_player_video_bo_info_t, bo list for decoded video data by sw codec */
 	int video_bo_size;
 	bool video_stream_prerolled;
 
 	/* audio stream callback */
 	mm_player_audio_stream_callback audio_stream_render_cb;
-	void* audio_stream_cb_user_param;
+	void *audio_stream_cb_user_param;
 	bool audio_stream_sink_sync;
-	GList* audio_stream_buff_list; /* mm_player_audio_stream_buff_t, buff list of extract pcm data */
+	GList *audio_stream_buff_list; /* mm_player_audio_stream_buff_t, buff list of extract pcm data */
 
 	/* video capture callback*/
 	gulong video_capture_cb_probe_id;
@@ -654,7 +654,7 @@ typedef struct {
 	gchar *type;
 
 	/* video stream caps parsed by demuxer */
-	GstCaps* v_stream_caps;
+	GstCaps *v_stream_caps;
 
 	/* audio effect infomation */
 	MMAudioEffectInfo audio_effect_info;
@@ -668,10 +668,10 @@ typedef struct {
 	MMStreamingType streaming_type;
 
 	/* autoplugging */
-	GList* factories;
+	GList *factories;
 	gboolean have_dynamic_pad;
-	GList* parsers; // list of linked parser name
-	GList* audio_decoders; // list of linked audio name
+	GList *parsers; // list of linked parser name
+	GList *audio_decoders; // list of linked audio name
 	gboolean no_more_pad;
 	gint num_dynamic_pad;
 	gboolean has_many_types;
@@ -727,10 +727,10 @@ typedef struct {
 	gboolean msg_posted;
 
 	/* list of sink elements */
-	GList* sink_elements;
+	GList *sink_elements;
 
 	/* signal notifiers */
-	GList* signals[MM_PLAYER_SIGNAL_TYPE_MAX];
+	GList *signals[MM_PLAYER_SIGNAL_TYPE_MAX];
 	guint bus_watcher;
 	GQueue *bus_msg_q;
 	GMutex bus_msg_q_lock;
@@ -771,7 +771,7 @@ typedef struct {
 
 	/* PD downloader message callback and param */
 	MMMessageCallback pd_msg_cb;
-	void* pd_msg_cb_param;
+	void *pd_msg_cb_param;
 
 	/* adjust subtitle position store */
 	gint64 adjust_subtitle_pos;
@@ -807,7 +807,7 @@ typedef struct {
 	gboolean sync_handler;
 
 	/* store dump pad list */
-	GList* dump_list;
+	GList *dump_list;
 
 	/* whether a video has closed caption or not */
 	gboolean has_closed_caption;
@@ -815,10 +815,10 @@ typedef struct {
 	GstElement *video_fakesink;
 
 	/* audio stream caps parsed by demuxer or set by external demuxer */
-	GstCaps* a_stream_caps;
+	GstCaps *a_stream_caps;
 
 	/* subtitle stream caps parsed by demuxer or set by external demuxer */
-	GstCaps* s_stream_caps;
+	GstCaps *s_stream_caps;
 
 	/* es player using feed-data callback or calling app_src_push_buffer directly*/
 	gboolean es_player_push_mode;
@@ -881,11 +881,11 @@ int _mmplayer_create_player(MMHandleType hplayer);
 int _mmplayer_destroy(MMHandleType hplayer);
 int _mmplayer_realize(MMHandleType hplayer);
 int _mmplayer_unrealize(MMHandleType hplayer);
-int _mmplayer_get_state(MMHandleType hplayer, int* pstate);
+int _mmplayer_get_state(MMHandleType hplayer, int *pstate);
 int _mmplayer_set_volume(MMHandleType hplayer, MMPlayerVolumeType volume);
 int _mmplayer_get_volume(MMHandleType hplayer, MMPlayerVolumeType *volume);
 int _mmplayer_set_mute(MMHandleType hplayer, int mute);
-int _mmplayer_get_mute(MMHandleType hplayer, int* pmute);
+int _mmplayer_get_mute(MMHandleType hplayer, int *pmute);
 int _mmplayer_start(MMHandleType hplayer);
 int _mmplayer_stop(MMHandleType hplayer);
 int _mmplayer_pause(MMHandleType hplayer);
@@ -901,30 +901,30 @@ int _mmplayer_set_videostream_changed_cb(MMHandleType hplayer, mm_player_stream_
 int _mmplayer_set_audiostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param);
 int _mmplayer_set_videostream_cb(MMHandleType hplayer, mm_player_video_stream_callback callback, void *user_param);
 int _mmplayer_set_subtitle_silent(MMHandleType hplayer, int silent);
-int _mmplayer_get_subtitle_silent(MMHandleType hplayer, int* silent);
-int _mmplayer_set_external_subtitle_path(MMHandleType hplayer, const char* filepath);
-int _mmplayer_get_buffer_position(MMHandleType hplayer, int format, unsigned long* start_pos, unsigned long* stop_pos);
-int _mmplayer_update_video_param(mm_player_t* player, char *param_name);
+int _mmplayer_get_subtitle_silent(MMHandleType hplayer, int *silent);
+int _mmplayer_set_external_subtitle_path(MMHandleType hplayer, const char *filepath);
+int _mmplayer_get_buffer_position(MMHandleType hplayer, int format, unsigned long *start_pos, unsigned long *stop_pos);
+int _mmplayer_update_video_param(mm_player_t *player, char *param_name);
 int _mmplayer_change_videosink(MMHandleType handle, MMDisplaySurfaceType surface_type, void *display_overlay);
 int _mmplayer_audio_effect_custom_apply(mm_player_t *player);
 int _mmplayer_set_audiostream_cb(MMHandleType hplayer, bool sync, mm_player_audio_stream_callback callback, void *user_param);
 int _mmplayer_change_track_language(MMHandleType hplayer, MMPlayerTrackType type, int index);
-int _mmplayer_sync_subtitle_pipeline(mm_player_t* player);
+int _mmplayer_sync_subtitle_pipeline(mm_player_t *player);
 int _mmplayer_set_video_hub_download_mode(MMHandleType hplayer, bool mode);
 int _mmplayer_use_system_clock(MMHandleType hplayer);
 int _mmplayer_set_video_share_master_clock(MMHandleType hplayer, gint64 clock, gint64 clock_delta, gint64 video_time, gint64 media_clock, gint64 audio_time);
 int _mmplayer_get_video_share_master_clock(MMHandleType hplayer, gint64 *video_time, gint64 *media_clock, gint64 *audio_time);
 int _mmplayer_enable_sync_handler(MMHandleType hplayer, bool enable);
-int _mmplayer_set_file_buffering_path(MMHandleType hplayer, const char* file_path);
-int _mmplayer_set_uri(MMHandleType hplayer, const char* uri);
-int _mmplayer_set_next_uri(MMHandleType hplayer, const char* uri, bool is_first_path);
-int _mmplayer_get_next_uri(MMHandleType hplayer, char** uri);
+int _mmplayer_set_file_buffering_path(MMHandleType hplayer, const char *file_path);
+int _mmplayer_set_uri(MMHandleType hplayer, const char *uri);
+int _mmplayer_set_next_uri(MMHandleType hplayer, const char *uri, bool is_first_path);
+int _mmplayer_get_next_uri(MMHandleType hplayer, char **uri);
 int _mmplayer_has_closed_caption(MMHandleType hplayer, bool* exist);
 void _mm_player_video_stream_internal_buffer_unref(void *buffer);
 int _mmplayer_get_timeout(MMHandleType hplayer, int *timeout);
 int _mmplayer_get_num_of_video_out_buffers(MMHandleType hplayer, int *num, int *extra_num);
 int _mmplayer_manage_external_storage_state(MMHandleType hplayer, int id, int state);
-int _mmplayer_video_stream_release_bo(mm_player_t* player, void* bo);
+int _mmplayer_video_stream_release_bo(mm_player_t *player, void *bo);
 int _mmplayer_get_adaptive_variant_info(MMHandleType hplayer, int *num, char **var_info);
 int _mmplayer_set_max_adaptive_variant_limit(MMHandleType hplayer, int bandwidth, int width, int height);
 int _mmplayer_get_max_adaptive_variant_limit(MMHandleType hplayer, int *bandwidth, int *width, int *height);
@@ -941,24 +941,24 @@ int _mmplayer_get_video_roi_area(MMHandleType hplayer, double *scale_x, double *
 /* internal */
 void __mmplayer_bus_msg_thread_destroy(MMHandleType hplayer);
 
-void __mmplayer_set_state(mm_player_t* player, int state);
-int __mmplayer_check_state(mm_player_t* player, enum PlayerCommandState command);
-gboolean __mmplayer_update_content_attrs(mm_player_t* player, enum content_attr_flag flag);
-void __mmplayer_cancel_eos_timer(mm_player_t* player);
-void __mmplayer_audio_stream_clear_buffer(mm_player_t* player, gboolean send_all);
-MMStreamingType __mmplayer_get_stream_service_type(mm_player_t* player);
-int __mmplayer_get_video_angle(mm_player_t* player, int *display_angle, int *orientations);
-gboolean __mmplayer_gst_remove_fakesink(mm_player_t* player, MMPlayerGstElement* fakesink);
-void __mmplayer_add_signal_connection(mm_player_t* player, GObject* object, MMPlayerSignalType type, const gchar* signal, GCallback cb_funct, gpointer u_data);
+void __mmplayer_set_state(mm_player_t *player, int state);
+int __mmplayer_check_state(mm_player_t *player, enum PlayerCommandState command);
+gboolean __mmplayer_update_content_attrs(mm_player_t *player, enum content_attr_flag flag);
+void __mmplayer_cancel_eos_timer(mm_player_t *player);
+void __mmplayer_audio_stream_clear_buffer(mm_player_t *player, gboolean send_all);
+MMStreamingType __mmplayer_get_stream_service_type(mm_player_t *player);
+int __mmplayer_get_video_angle(mm_player_t *player, int *display_angle, int *orientations);
+gboolean __mmplayer_gst_remove_fakesink(mm_player_t *player, MMPlayerGstElement *fakesink);
+void __mmplayer_add_signal_connection(mm_player_t *player, GObject *object, MMPlayerSignalType type, const gchar *signal, GCallback cb_funct, gpointer u_data);
 void __mmplayer_gst_decode_pad_added(GstElement *elem, GstPad *pad, gpointer data);
-gint __mmplayer_gst_decode_autoplug_select(GstElement *bin,  GstPad* pad, GstCaps* caps, GstElementFactory* factory, gpointer data);
-gboolean __mmplayer_gst_create_decoder(mm_player_t* player, GstPad *srcpad, const GstCaps *caps);
+gint __mmplayer_gst_decode_autoplug_select(GstElement *bin,  GstPad *pad, GstCaps *caps, GstElementFactory *factory, gpointer data);
+gboolean __mmplayer_gst_create_decoder(mm_player_t *player, GstPad *srcpad, const GstCaps *caps);
 void __mmplayer_gst_element_added(GstElement *bin, GstElement *element, gpointer data);
-GstElement* __mmplayer_gst_make_decodebin(mm_player_t* player);
-int __mmplayer_gst_element_add_bucket_to_bin(GstBin* bin, GList* element_bucket);
-int __mmplayer_gst_element_link_bucket(GList* element_bucket);
+GstElement* __mmplayer_gst_make_decodebin(mm_player_t *player);
+int __mmplayer_gst_element_add_bucket_to_bin(GstBin *bin, GList *element_bucket);
+int __mmplayer_gst_element_link_bucket(GList *element_bucket);
 void __mmplayer_typefind_have_type(GstElement *tf, guint probability, GstCaps *caps, gpointer data);
-int __mmplayer_parse_profile(const char *uri, void *param, MMPlayerParseProfile* data);
+int __mmplayer_parse_profile(const char *uri, void *param, MMPlayerParseProfile *data);
 
 
 #ifdef __cplusplus
diff --git a/src/include/mm_player_utils.h b/src/include/mm_player_utils.h
index efcb3f4..285b07d 100644
--- a/src/include/mm_player_utils.h
+++ b/src/include/mm_player_utils.h
@@ -120,43 +120,47 @@ do {	\
 #endif
 
 #define MMPLAYER_RETURN_IF_FAIL(expr) \
-if (!(expr)) { \
-	LOGW("faild [%s]", #expr); \
-	return; \
-}
+do { \
+	if (!(expr)) { \
+		LOGW("failed [%s]", #expr); \
+		return; \
+	} \
+} while (0)
 
 #define MMPLAYER_RETURN_VAL_IF_FAIL(expr, var) \
-if (!(expr)) { \
-	LOGW("faild [%s]", #expr); \
-	return (var); \
-}
+do { \
+	if (!(expr)) { \
+		LOGW("failed [%s]", #expr); \
+		return (var); \
+	} \
+} while (0)
 
 /* debug caps string */
 #define MMPLAYER_LOG_GST_CAPS_TYPE(x_caps) \
 do { \
-	gchar* caps_type = NULL; \
+	gchar *caps_type = NULL; \
 	caps_type = gst_caps_to_string(x_caps); \
-	LOGD("caps: %s\n", caps_type); \
+	LOGD("caps: %s", caps_type); \
 	MMPLAYER_FREEIF(caps_type); \
 } while (0)
 
 /* message posting */
 #define MMPLAYER_POST_MSG(x_player, x_msgtype, x_msg_param) \
 do { \
-	LOGD("[handle: %p] posting %s to application\n", x_player, #x_msgtype); \
+	LOGD("[handle: %p] posting %s to application", x_player, #x_msgtype); \
 	__mmplayer_post_message(x_player, x_msgtype, x_msg_param); \
 } while (0)
 
 /* setting player state */
 #define MMPLAYER_SET_STATE(x_player, x_state) \
 do { \
-	LOGD("[handle: %p] update state machine to %d\n", x_player, x_state); \
+	LOGD("[handle: %p] update state machine to %d", x_player, x_state); \
 	__mmplayer_set_state(x_player, x_state); \
 } while (0)
 
 #define MMPLAYER_CHECK_STATE(x_player, x_command) \
 do {	\
-	LOGD("[handle: %p] checking player state before doing %s\n", x_player, #x_command); \
+	LOGD("[handle: %p] checking player state before doing %s", x_player, #x_command); \
 	switch (__mmplayer_check_state(x_player, x_command)) { \
 	case MM_ERROR_PLAYER_INVALID_STATE: \
 		return MM_ERROR_PLAYER_INVALID_STATE; \
@@ -175,16 +179,16 @@ do {	\
 /* setting element state */
 #define MMPLAYER_ELEMENT_SET_STATE(x_element, x_state) \
 do {	\
-	LOGD("setting state [%s:%d] to [%s]\n", #x_state, x_state, GST_ELEMENT_NAME(x_element)); \
+	LOGD("setting state [%s:%d] to [%s]", #x_state, x_state, GST_ELEMENT_NAME(x_element)); \
 	if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(x_element, x_state)) { \
-		LOGE("failed to set state %s to %s\n", #x_state, GST_ELEMENT_NAME(x_element)); \
+		LOGE("failed to set state %s to %s", #x_state, GST_ELEMENT_NAME(x_element)); \
 		goto STATE_CHANGE_FAILED; \
 	}	\
 } while (0)
 
 #define MMPLAYER_CHECK_NULL(x_var) \
 if (!x_var) { \
-	LOGE("[%s] is NULL\n", #x_var); \
+	LOGE("[%s] is NULL", #x_var); \
 	goto ERROR; \
 }
 
@@ -198,10 +202,10 @@ if (x_player->ini.generate_dot) { \
 /* signal manipulation */
 #define MMPLAYER_SIGNAL_CONNECT(x_player, x_object, x_type, x_signal, x_callback, x_arg) \
 do { \
-	MMPlayerSignalItem* item = NULL; \
+	MMPlayerSignalItem *item = NULL; \
 	item = (MMPlayerSignalItem*) g_malloc(sizeof(MMPlayerSignalItem)); \
 	if (!item) { \
-		LOGE("cannot connect signal [%s]\n", x_signal); \
+		LOGE("cannot connect signal [%s]", x_signal); \
 	} else { \
 		item->obj = G_OBJECT(x_object); \
 		item->sig = g_signal_connect(G_OBJECT(x_object), x_signal, \
@@ -209,7 +213,7 @@ do { \
 		if ((x_type >= MM_PLAYER_SIGNAL_TYPE_AUTOPLUG) && (x_type < MM_PLAYER_SIGNAL_TYPE_MAX)) \
 			x_player->signals[x_type] = g_list_append(x_player->signals[x_type], item); \
 		else \
-			LOGE("wrong signal type [%d]\n", x_type); \
+			LOGE("wrong signal type [%d]", x_type); \
 	} \
 } while (0)
 
@@ -232,7 +236,7 @@ do { \
 #define MMPLAYER_STATE_GET_NAME(state) __get_state_name(state)
 
 #define MMPLAYER_PRINT_STATE(x_player) \
-LOGD("-- prev %s, current %s, pending %s, target %s --\n", \
+LOGD("-- prev %s, current %s, pending %s, target %s --", \
 	MMPLAYER_STATE_GET_NAME(MMPLAYER_PREV_STATE(x_player)), \
 	MMPLAYER_STATE_GET_NAME(MMPLAYER_CURRENT_STATE(x_player)), \
 	MMPLAYER_STATE_GET_NAME(MMPLAYER_PENDING_STATE(x_player)), \
diff --git a/src/mm_player_gst.c b/src/mm_player_gst.c
index 406b3ac..a2a3e0d 100644
--- a/src/mm_player_gst.c
+++ b/src/mm_player_gst.c
@@ -2564,12 +2564,13 @@ static void
 __mmplayer_gst_rtp_dynamic_pad(GstElement *element, GstPad *pad, gpointer data)
 {
 	GstPad *sinkpad = NULL;
-	GstCaps* caps = NULL;
-	GstElement* new_element = NULL;
-	GstStructure* str = NULL;
-	const gchar* name = NULL;
+	GstCaps *caps = NULL;
+	GstElement *new_element = NULL;
+	GstStructure *str = NULL;
+	const gchar *name = NULL;
+	gboolean caps_ret = TRUE;
 
-	mm_player_t* player = (mm_player_t*) data;
+	mm_player_t *player = (mm_player_t*) data;
 
 	MMPLAYER_FENTER();
 
@@ -2578,33 +2579,19 @@ __mmplayer_gst_rtp_dynamic_pad(GstElement *element, GstPad *pad, gpointer data)
 					player->pipeline &&
 					player->pipeline->mainbin);
 
+	MMPLAYER_GST_GET_CAPS_INFO(pad, caps, str, name, caps_ret);
+	if (!caps_ret)
+		goto ERROR;
 
 	/* payload type is recognizable. increase num_dynamic and wait for sinkbin creation.
 	 * num_dynamic_pad will decreased after creating a sinkbin.
 	 */
 	player->num_dynamic_pad++;
-	LOGD("stream count inc : %d\n", player->num_dynamic_pad);
-
-	caps = gst_pad_query_caps(pad, NULL);
-
-	MMPLAYER_CHECK_NULL(caps);
+	LOGD("stream count inc : %d", player->num_dynamic_pad);
 
 	/* clear  previous result*/
 	player->have_dynamic_pad = FALSE;
 
-	str = gst_caps_get_structure(caps, 0);
-
-	if (!str) {
-		LOGE("cannot get structure from caps.\n");
-		goto ERROR;
-	}
-
-	name = gst_structure_get_name(str);
-	if (!name) {
-		LOGE("cannot get mimetype from structure.\n");
-		goto ERROR;
-	}
-
 	if (strstr(name, "video")) {
 		gint stype = 0;
 		mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &stype);
diff --git a/src/mm_player_priv.c b/src/mm_player_priv.c
index 482ae9e..64c1551 100644
--- a/src/mm_player_priv.c
+++ b/src/mm_player_priv.c
@@ -885,15 +885,16 @@ __mmplayer_gst_selector_update_start_time(mm_player_t* player, MMPlayerTrackType
 }
 
 static GstPadProbeReturn
-__mmplayer_gst_selector_event_probe(GstPad * pad, GstPadProbeInfo * info, gpointer data)
+__mmplayer_gst_selector_event_probe(GstPad *pad, GstPadProbeInfo *info, gpointer data)
 {
 	GstPadProbeReturn ret = GST_PAD_PROBE_OK;
 	GstEvent *event = GST_PAD_PROBE_INFO_DATA(info);
-	mm_player_t* player = (mm_player_t*)data;
-	GstCaps* caps = NULL;
-	GstStructure* str = NULL;
-	const gchar* name = NULL;
+	mm_player_t *player = (mm_player_t*)data;
+	GstCaps *caps = NULL;
+	GstStructure *str = NULL;
+	const gchar *name = NULL;
 	MMPlayerTrackType stream_type = MM_PLAYER_TRACK_TYPE_VIDEO;
+	gboolean caps_ret = TRUE;
 
 	if (GST_EVENT_IS_DOWNSTREAM(event) &&
 	    GST_EVENT_TYPE(event) != GST_EVENT_STREAM_START &&
@@ -906,23 +907,9 @@ __mmplayer_gst_selector_event_probe(GstPad * pad, GstPadProbeInfo * info, gpoint
 		return ret;
 	}
 
-	caps = gst_pad_query_caps(pad, NULL);
-	if (!caps) {
-		LOGE("failed to get caps from pad[%s:%s]", GST_DEBUG_PAD_NAME(pad));
-		return ret;
-	}
-
-	str = gst_caps_get_structure(caps, 0);
-	if (!str) {
-		LOGE("failed to get structure from caps");
-		goto ERROR;
-	}
-
-	name = gst_structure_get_name(str);
-	if (!name) {
-		LOGE("failed to get name from str");
+	MMPLAYER_GST_GET_CAPS_INFO(pad, caps, str, name, caps_ret);
+	if (!caps_ret)
 		goto ERROR;
-	}
 
 	if (strstr(name, "audio")) {
 		stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
@@ -1045,236 +1032,241 @@ ERROR:
 	return ret;
 }
 
-void
-__mmplayer_gst_decode_pad_added(GstElement *elem, GstPad *pad, gpointer data)
+/* create fakesink for audio or video path witout audiobin or videobin */
+static void
+__mmplayer_gst_make_fakesink(mm_player_t *player, GstPad *pad, const gchar *name)
 {
-	mm_player_t* player = NULL;
-	GstElement* pipeline = NULL;
-	GstElement* selector = NULL;
-	GstElement* fakesink = NULL;
-	GstCaps* caps = NULL;
-	GstStructure* str = NULL;
-	const gchar* name = NULL;
-	GstPad* sinkpad = NULL;
-	GstPad* srcpad = NULL;
-	gboolean first_track = FALSE;
-
-	enum MainElementID elemId = MMPLAYER_M_NUM;
-	MMPlayerTrackType stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
-
-	/* check handles */
-	player = (mm_player_t*)data;
+	GstElement *pipeline = NULL;
+	GstElement *fakesink = NULL;
+	GstPad *sinkpad = NULL;
 
-	MMPLAYER_RETURN_IF_FAIL(elem && pad);
+	MMPLAYER_FENTER();
 	MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->mainbin);
 
-	//LOGD("pad-added signal handling\n");
-
 	pipeline = player->pipeline->mainbin[MMPLAYER_M_PIPE].gst;
 
-	/* get mimetype from caps */
-	caps = gst_pad_query_caps(pad, NULL);
-	if (!caps) {
-		LOGE("cannot get caps from pad.\n");
-		goto ERROR;
+	/* fake sink */
+	fakesink = gst_element_factory_make("fakesink", NULL);
+	if (fakesink == NULL) {
+		LOGE("failed to create fakesink");
+		goto EXIT;
 	}
 
-	str = gst_caps_get_structure(caps, 0);
-	if (!str) {
-		LOGE("cannot get structure from caps.\n");
-		goto ERROR;
-	}
+	/* store it as it's sink element */
+	__mmplayer_add_sink(player, fakesink);
 
-	name = gst_structure_get_name(str);
-	if (!name) {
-		LOGE("cannot get mimetype from structure.\n");
-		goto ERROR;
-	}
+	gst_bin_add(GST_BIN(pipeline), fakesink);
 
-	MMPLAYER_LOG_GST_CAPS_TYPE(caps);
-	//LOGD("detected mimetype : %s\n", name);
+	/* link */
+	sinkpad = gst_element_get_static_pad(fakesink, "sink");
+
+	LOGD("pad link %s:%s - %s:%s", GST_DEBUG_PAD_NAME(pad), GST_DEBUG_PAD_NAME(sinkpad));
+
+	if (gst_pad_link(pad, sinkpad) != GST_PAD_LINK_OK) {
+		LOGE("failed to link fakesink");
+		gst_object_unref(GST_OBJECT(fakesink));
+		goto EXIT;
+	}
 
 	if (strstr(name, "video")) {
-		gint stype = 0;
+		player->video_fakesink = fakesink;
 
-		mm_attrs_set_int_by_name(player->attrs, "content_video_found", TRUE);
-		mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &stype);
+		if (player->v_stream_caps) {
+			gst_caps_unref(player->v_stream_caps);
+			player->v_stream_caps = NULL;
+		}
 
-		/* don't make video because of not required, and not support multiple track */
-		if (stype == MM_DISPLAY_SURFACE_NULL) {
-			LOGD("no video sink by null surface");
+		if (player->ini.set_dump_element_flag)
+			__mmplayer_add_dump_buffer_probe(player, fakesink);
 
-			gchar *caps_str = gst_caps_to_string(caps);
-			if (caps_str && (strstr(caps_str, "ST12") || strstr(caps_str, "SN12") ||
-				strstr(caps_str, "SN21") || strstr(caps_str, "S420") || strstr(caps_str, "SR32")))
-				player->set_mode.video_zc = TRUE;
 
-			MMPLAYER_FREEIF(caps_str);
+		if (player->set_mode.media_packet_video_stream) { /* export video decoded frame */
+			g_object_set(G_OBJECT(fakesink), "signal-handoffs", TRUE, "max-lateness", FAKE_SINK_MAX_LATENESS, NULL);
 
-			if (player->v_stream_caps) {
-				gst_caps_unref(player->v_stream_caps);
-				player->v_stream_caps = NULL;
-			}
+			__mmplayer_add_signal_connection(player,
+									G_OBJECT(fakesink),
+									MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
+									"handoff",
+									G_CALLBACK(__mmplayer_video_stream_decoded_render_cb),
+									(gpointer)player);
 
-			LOGD("create fakesink instead of videobin");
+			__mmplayer_add_signal_connection(player,
+									G_OBJECT(fakesink),
+									MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
+									"preroll-handoff",
+									G_CALLBACK(__mmplayer_video_stream_decoded_preroll_cb),
+									(gpointer)player);
+		}
+	}
 
-			/* fake sink */
-			fakesink = gst_element_factory_make("fakesink", NULL);
-			if (fakesink == NULL) {
-				LOGE("ERROR : fakesink create error\n");
-				goto ERROR;
-			}
+	g_object_set(G_OBJECT(fakesink), "sync", TRUE, NULL);
+	gst_element_set_state(fakesink, GST_STATE_PAUSED);
 
-			if (player->ini.set_dump_element_flag)
-				__mmplayer_add_dump_buffer_probe(player, fakesink);
+EXIT:
+	if (sinkpad)
+		gst_object_unref(GST_OBJECT(sinkpad));
 
-			player->video_fakesink = fakesink;
+	MMPLAYER_FLEAVE();
+	return;
+}
 
-			/* store it as it's sink element */
-			__mmplayer_add_sink(player, player->video_fakesink);
+static GstElement*
+__mmplayer_gst_make_selector(mm_player_t *player, enum MainElementID elem_idx, MMPlayerTrackType stream_type)
+{
+	GstElement *pipeline = NULL;
+	GstElement *selector = NULL;
+	GstPad *srcpad = NULL;
 
-			gst_bin_add(GST_BIN(pipeline), fakesink);
+	MMPLAYER_FENTER();
+	MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline && player->pipeline->mainbin, NULL);
 
-			// link
-			sinkpad = gst_element_get_static_pad(fakesink, "sink");
+	selector = gst_element_factory_make("input-selector", NULL);
+	if (!selector) {
+		LOGE("failed to create input-selector");
+		return NULL;
+	}
+	g_object_set(selector, "sync-streams", TRUE, NULL);
 
-			if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad)) {
-				LOGW("failed to link fakesink\n");
-				gst_object_unref(GST_OBJECT(fakesink));
-				goto ERROR;
-			}
+	player->pipeline->mainbin[elem_idx].id = elem_idx;
+	player->pipeline->mainbin[elem_idx].gst = selector;
 
-			if (player->set_mode.media_packet_video_stream) {
-				g_object_set(G_OBJECT(fakesink), "signal-handoffs", TRUE, "max-lateness", FAKE_SINK_MAX_LATENESS, NULL);
-
-				__mmplayer_add_signal_connection(player,
-										G_OBJECT(fakesink),
-										MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
-										"handoff",
-										G_CALLBACK(__mmplayer_video_stream_decoded_render_cb),
-										(gpointer)player);
-
-				__mmplayer_add_signal_connection(player,
-										G_OBJECT(fakesink),
-										MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
-										"preroll-handoff",
-										G_CALLBACK(__mmplayer_video_stream_decoded_preroll_cb),
-										(gpointer)player);
-			}
+	/* player->selector[stream_type].active_pad_index = DEFAULT_TRACK; */
 
-			g_object_set(G_OBJECT(fakesink), "async", TRUE, "sync", TRUE, NULL);
-			gst_element_set_state(fakesink, GST_STATE_PAUSED);
-			goto DONE;
-		}
+	srcpad = gst_element_get_static_pad(selector, "src");
 
-		if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
-			__mmplayer_gst_decode_callback(elem, pad, player);
-			goto DONE;
-		}
+	LOGD("blocking %s:%s", GST_DEBUG_PAD_NAME(srcpad));
+	player->selector[stream_type].block_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
+		__mmplayer_gst_selector_blocked, NULL, NULL);
+	player->selector[stream_type].event_probe_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_EVENT_BOTH|GST_PAD_PROBE_TYPE_EVENT_FLUSH,
+		__mmplayer_gst_selector_event_probe, player, NULL);
 
-		LOGD("video selector \n");
-		elemId = MMPLAYER_M_V_INPUT_SELECTOR;
-		stream_type = MM_PLAYER_TRACK_TYPE_VIDEO;
-	} else {
-		if (strstr(name, "audio")) {
-			gint samplerate = 0;
-			gint channels = 0;
+	gst_element_set_state(selector, GST_STATE_PAUSED);
 
-			if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
-				__mmplayer_gst_decode_callback(elem, pad, player);
-				goto DONE;
-			}
+	pipeline = player->pipeline->mainbin[MMPLAYER_M_PIPE].gst;
+	gst_bin_add(GST_BIN(pipeline), selector);
 
-			LOGD("audio selector \n");
-			elemId = MMPLAYER_M_A_INPUT_SELECTOR;
-			stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
+	MMPLAYER_FLEAVE();
+	return selector;
+}
 
-			gst_structure_get_int(str, "rate", &samplerate);
-			gst_structure_get_int(str, "channels", &channels);
+void
+__mmplayer_gst_decode_pad_added(GstElement *elem, GstPad *pad, gpointer data)
+{
+	mm_player_t *player = NULL;
+	GstElement *selector = NULL;
+	GstCaps *caps = NULL;
+	GstStructure *str = NULL;
+	const gchar *name = NULL;
+	GstPad *sinkpad = NULL;
+	GstPad *srcpad = NULL;
+	gboolean first_track = FALSE;
+	gboolean caps_ret = TRUE;
 
-			if ((channels > 0 && samplerate == 0)) {//exclude audio decoding
-				/* fake sink */
-				fakesink = gst_element_factory_make("fakesink", NULL);
-				if (fakesink == NULL) {
-					LOGE("ERROR : fakesink create error\n");
-					goto ERROR;
-				}
+	enum MainElementID elem_idx = MMPLAYER_M_NUM;
+	MMPlayerTrackType stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
 
-				gst_bin_add(GST_BIN(pipeline), fakesink);
+	/* check handles */
+	player = (mm_player_t*)data;
 
-				/* link */
-				sinkpad = gst_element_get_static_pad(fakesink, "sink");
+	MMPLAYER_FENTER();
+	MMPLAYER_RETURN_IF_FAIL(elem && pad);
+	MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->mainbin);
 
-				if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad)) {
-					LOGW("failed to link fakesink\n");
-					gst_object_unref(GST_OBJECT(fakesink));
-					goto ERROR;
-				}
+	/* get mimetype from caps */
+	MMPLAYER_GST_GET_CAPS_INFO(pad, caps, str, name, caps_ret);
+	if (!caps_ret)
+		goto ERROR;
 
-				g_object_set(G_OBJECT(fakesink), "sync", TRUE, NULL);
-				gst_element_set_state(fakesink, GST_STATE_PAUSED);
+	MMPLAYER_LOG_GST_CAPS_TYPE(caps);
+	/* LOGD("detected mimetype : %s", name); */
 
-				goto DONE;
-			}
-		} else if (strstr(name, "text")) {
-			LOGD("text selector \n");
-			elemId = MMPLAYER_M_T_INPUT_SELECTOR;
-			stream_type = MM_PLAYER_TRACK_TYPE_TEXT;
-		} else {
-			LOGE("wrong elem id \n");
-			goto ERROR;
+	if (strstr(name, "video")) {
+		gint stype = 0;
+		gchar *caps_str = NULL;
+
+		caps_str = gst_caps_to_string(caps);
+		if (caps_str && (strstr(caps_str, "ST12") || strstr(caps_str, "SN12") ||
+			strstr(caps_str, "SN21") || strstr(caps_str, "S420") || strstr(caps_str, "SR32")))
+			player->set_mode.video_zc = TRUE;
+
+		MMPLAYER_FREEIF(caps_str);
+
+		mm_attrs_set_int_by_name(player->attrs, "content_video_found", TRUE);
+		mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &stype);
+
+		LOGD("surface type : %d", stype);
+
+		if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
+			__mmplayer_gst_decode_callback(elem, pad, player);
+			goto DONE;
 		}
-	}
 
-	selector = player->pipeline->mainbin[elemId].gst;
-	if (selector == NULL) {
-		selector = gst_element_factory_make("input-selector", NULL);
-		LOGD("Creating input-selector\n");
-		if (selector == NULL) {
-			LOGE("ERROR : input-selector create error\n");
-			goto ERROR;
+		if (stype == MM_DISPLAY_SURFACE_NULL) {
+			__mmplayer_gst_make_fakesink(player, pad, name);
+			goto DONE;
 		}
-		g_object_set(selector, "sync-streams", TRUE, NULL);
 
-		player->pipeline->mainbin[elemId].id = elemId;
-		player->pipeline->mainbin[elemId].gst = selector;
+		LOGD("video selector is required");
+		elem_idx = MMPLAYER_M_V_INPUT_SELECTOR;
+		stream_type = MM_PLAYER_TRACK_TYPE_VIDEO;
+	} else if (strstr(name, "audio")) {
+		gint samplerate = 0;
+		gint channels = 0;
 
-		first_track = TRUE;
-		// player->selector[stream_type].active_pad_index = DEFAULT_TRACK;	// default
+		gst_structure_get_int(str, "rate", &samplerate);
+		gst_structure_get_int(str, "channels", &channels);
 
-		srcpad = gst_element_get_static_pad(selector, "src");
+		if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
+			__mmplayer_gst_decode_callback(elem, pad, player);
+			goto DONE;
+		}
 
-		LOGD("blocking %s:%s", GST_DEBUG_PAD_NAME(srcpad));
-		player->selector[stream_type].block_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
-			__mmplayer_gst_selector_blocked, NULL, NULL);
-		player->selector[stream_type].event_probe_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_EVENT_BOTH|GST_PAD_PROBE_TYPE_EVENT_FLUSH,
-			__mmplayer_gst_selector_event_probe, player, NULL);
+		if ((channels > 0 && samplerate == 0)) { /* exclude audio decoding */
+			__mmplayer_gst_make_fakesink(player, pad, name);
+			goto DONE;
+		}
 
-		gst_element_set_state(selector, GST_STATE_PAUSED);
-		gst_bin_add(GST_BIN(pipeline), selector);
-	} else
-		LOGD("input-selector is already created.\n");
+		LOGD("audio selector is required");
+		elem_idx = MMPLAYER_M_A_INPUT_SELECTOR;
+		stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
+
+	} else if (strstr(name, "text")) {
+		LOGD("text selector is required");
+		elem_idx = MMPLAYER_M_T_INPUT_SELECTOR;
+		stream_type = MM_PLAYER_TRACK_TYPE_TEXT;
+	} else {
+		LOGE("invalid caps info");
+		goto ERROR;
+	}
 
-	// link
-	LOGD("Calling request pad with selector %p \n", selector);
+	/* check selector and create it */
+	if (!(selector = player->pipeline->mainbin[elem_idx].gst)) {
+		selector = __mmplayer_gst_make_selector(player, elem_idx, stream_type);
+		if (!selector)
+			goto ERROR;
+		first_track = TRUE;
+	} else {
+		LOGD("input-selector is already created.");
+	}
+
+	/* link */
 	sinkpad = gst_element_get_request_pad(selector, "sink_%u");
 
-	LOGD("got pad %s:%s from selector", GST_DEBUG_PAD_NAME(sinkpad));
+	LOGD("pad link: %s:%s - %s:%s", GST_DEBUG_PAD_NAME(pad), GST_DEBUG_PAD_NAME(sinkpad));
 
-	if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad)) {
-		LOGW("failed to link selector\n");
+	if (gst_pad_link(pad, sinkpad) != GST_PAD_LINK_OK) {
+		LOGE("failed to link selector");
 		gst_object_unref(GST_OBJECT(selector));
 		goto ERROR;
 	}
 
 	if (first_track) {
-		LOGD("this is first track --> active track \n");
+		LOGD("this track will be activated");
 		g_object_set(selector, "active-pad", sinkpad, NULL);
 	}
 
 	__mmplayer_track_update_info(player, stream_type, sinkpad);
 
-
 DONE:
 ERROR:
 
@@ -1849,17 +1841,18 @@ ERROR:
 static void
 __mmplayer_gst_decode_callback(GstElement *elem, GstPad *pad, gpointer data)
 {
-	mm_player_t* player = NULL;
+	mm_player_t *player = NULL;
 	MMHandleType attrs = 0;
-	GstElement* pipeline = NULL;
-	GstCaps* caps = NULL;
-	gchar* caps_str = NULL;
-	GstStructure* str = NULL;
-	const gchar* name = NULL;
-	GstPad* sinkpad = NULL;
-	GstElement* sinkbin = NULL;
+	GstElement *pipeline = NULL;
+	GstCaps *caps = NULL;
+	gchar *caps_str = NULL;
+	GstStructure *str = NULL;
+	const gchar *name = NULL;
+	GstPad *sinkpad = NULL;
+	GstElement *sinkbin = NULL;
 	gboolean reusing = FALSE;
 	GstElement *text_selector = NULL;
+	gboolean caps_ret = TRUE;
 
 	/* check handles */
 	player = (mm_player_t*) data;
@@ -1875,25 +1868,11 @@ __mmplayer_gst_decode_callback(GstElement *elem, GstPad *pad, gpointer data)
 		goto ERROR;
 	}
 
-	/* get mimetype from caps */
-	caps = gst_pad_query_caps(pad, NULL);
-	if (!caps) {
-		LOGE("cannot get caps from pad.\n");
+	MMPLAYER_GST_GET_CAPS_INFO(pad, caps, str, name, caps_ret);
+	if (!caps_ret)
 		goto ERROR;
-	}
-	caps_str = gst_caps_to_string(caps);
 
-	str = gst_caps_get_structure(caps, 0);
-	if (!str) {
-		LOGE("cannot get structure from caps.\n");
-		goto ERROR;
-	}
-
-	name = gst_structure_get_name(str);
-	if (!name) {
-		LOGE("cannot get mimetype from structure.\n");
-		goto ERROR;
-	}
+	caps_str = gst_caps_to_string(caps);
 
 	/* LOGD("detected mimetype : %s", name); */
 	if (strstr(name, "audio")) {
@@ -2660,38 +2639,35 @@ __mmplayer_gst_element_add_bucket_to_bin(GstBin* bin, GList* element_bucket)
 	return successful_add_count;
 }
 
-static void __mmplayer_gst_caps_notify_cb(GstPad * pad, GParamSpec * unused, gpointer data)
+static void __mmplayer_gst_caps_notify_cb(GstPad *pad, GParamSpec *unused, gpointer data)
 {
-	mm_player_t* player = (mm_player_t*) data;
+	mm_player_t *player = (mm_player_t*) data;
 	GstCaps *caps = NULL;
 	GstStructure *str = NULL;
 	const char *name;
+	gboolean caps_ret = TRUE;
 
 	MMPLAYER_FENTER();
 
-	MMPLAYER_RETURN_IF_FAIL(pad)
-	MMPLAYER_RETURN_IF_FAIL(unused)
-	MMPLAYER_RETURN_IF_FAIL(data)
+	MMPLAYER_RETURN_IF_FAIL(pad);
+	MMPLAYER_RETURN_IF_FAIL(unused);
+	MMPLAYER_RETURN_IF_FAIL(data);
 
 	caps = gst_pad_get_current_caps(pad);
 	if (!caps)
 		return;
 
-	str = gst_caps_get_structure(caps, 0);
-	if (!str)
-		goto ERROR;
-
-	name = gst_structure_get_name(str);
-	if (!name)
+	MMPLAYER_GST_GET_CAPS_INFO(pad, caps, str, name, caps_ret);
+	if (!caps_ret)
 		goto ERROR;
 
-	LOGD("name = %s\n", name);
+	LOGD("name = %s", name);
 
 	if (strstr(name, "audio")) {
 		__mmplayer_update_content_attrs(player, ATTR_AUDIO);
 
 		if (player->audio_stream_changed_cb) {
-			LOGE("call the audio stream changed cb\n");
+			LOGE("call the audio stream changed cb");
 			player->audio_stream_changed_cb(player->audio_stream_changed_cb_user_param);
 		}
 	} else if (strstr(name, "video")) {
@@ -2701,15 +2677,16 @@ static void __mmplayer_gst_caps_notify_cb(GstPad * pad, GParamSpec * unused, gpo
 		__mmplayer_update_content_attrs(player, ATTR_VIDEO);
 
 		if (player->video_stream_changed_cb) {
-			LOGE("call the video stream changed cb\n");
+			LOGE("call the video stream changed cb");
 			player->video_stream_changed_cb(player->video_stream_changed_cb_user_param);
 		}
-	} else
-		goto ERROR;
+	} else {
+		LOGW("invalid caps info");
+	}
 
 ERROR:
-
-	gst_caps_unref(caps);
+	if (caps)
+		gst_caps_unref(caps);
 
 	MMPLAYER_FLEAVE();
 
@@ -5342,7 +5319,7 @@ _mmplayer_realize(MMHandleType hplayer)
 	MMPLAYER_FENTER();
 
 	/* check player handle */
-	MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED)
+	MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 
 	/* check current state */
 	MMPLAYER_CHECK_STATE(player, MMPLAYER_COMMAND_REALIZE);
@@ -6978,7 +6955,7 @@ __mmplayer_activate_next_source(mm_player_t *player, GstState target)
 	GstElement *element = NULL;
 	MMHandleType attrs = 0;
 	char *uri = NULL;
-	enum MainElementID elemId = MMPLAYER_M_NUM;
+	enum MainElementID elem_idx = MMPLAYER_M_NUM;
 
 	MMPLAYER_FENTER();
 
@@ -7039,18 +7016,18 @@ __mmplayer_activate_next_source(mm_player_t *player, GstState target)
 			__mm_player_streaming_initialize(player->streamer);
 		}
 
-		elemId = MMPLAYER_M_TYPEFIND;
+		elem_idx = MMPLAYER_M_TYPEFIND;
 		element = gst_element_factory_make("typefind", "typefinder");
 		__mmplayer_add_signal_connection(player, G_OBJECT(element),
 			MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "have-type", G_CALLBACK(__mmplayer_typefind_have_type), (gpointer)player);
 	} else {
-		elemId = MMPLAYER_M_AUTOPLUG;
+		elem_idx = MMPLAYER_M_AUTOPLUG;
 		element = __mmplayer_gst_make_decodebin(player);
 	}
 
 	/* check autoplug element is OK */
 	if (!element) {
-		LOGE("can not create element(%d)", elemId);
+		LOGE("can not create element(%d)", elem_idx);
 		goto ERROR;
 	}
 
@@ -7061,10 +7038,10 @@ __mmplayer_activate_next_source(mm_player_t *player, GstState target)
 		goto ERROR;
 	}
 
-	mainbin[elemId].id = elemId;
-	mainbin[elemId].gst = element;
+	mainbin[elem_idx].id = elem_idx;
+	mainbin[elem_idx].gst = element;
 
-	if (gst_element_link(mainbin[MMPLAYER_M_SRC].gst, mainbin[elemId].gst) == FALSE) {
+	if (gst_element_link(mainbin[MMPLAYER_M_SRC].gst, mainbin[elem_idx].gst) == FALSE) {
 		LOGE("Failed to link src - autoplug(or typefind)");
 		goto ERROR;
 	}
@@ -8628,7 +8605,7 @@ __mmplayer_change_selector_pad(mm_player_t* player, MMPlayerTrackType type, int
 	gchar* change_pad_name = NULL;
 	GstPad* sinkpad = NULL;
 	MMPlayerGstElement* mainbin = NULL;
-	enum MainElementID elemId = MMPLAYER_M_NUM;
+	enum MainElementID elem_idx = MMPLAYER_M_NUM;
 	GstCaps* caps = NULL;
 	gint total_track_num = 0;
 
@@ -8642,16 +8619,16 @@ __mmplayer_change_selector_pad(mm_player_t* player, MMPlayerTrackType type, int
 	mainbin = player->pipeline->mainbin;
 
 	if (type == MM_PLAYER_TRACK_TYPE_AUDIO) {
-		elemId = MMPLAYER_M_A_INPUT_SELECTOR;
+		elem_idx = MMPLAYER_M_A_INPUT_SELECTOR;
 	} else if (type == MM_PLAYER_TRACK_TYPE_TEXT) {
-		elemId = MMPLAYER_M_T_INPUT_SELECTOR;
+		elem_idx = MMPLAYER_M_T_INPUT_SELECTOR;
 	} else {
 		/* Changing Video Track is not supported. */
 		LOGE("Track Type Error\n");
 		goto EXIT;
 	}
 
-	if (mainbin[elemId].gst == NULL) {
+	if (mainbin[elem_idx].gst == NULL) {
 		result = MM_ERROR_PLAYER_NO_OP;
 		LOGD("Req track doesn't exist\n");
 		goto EXIT;
@@ -8680,7 +8657,7 @@ __mmplayer_change_selector_pad(mm_player_t* player, MMPlayerTrackType type, int
 
 	LOGD("new active pad name: %s\n", change_pad_name);
 
-	sinkpad = gst_element_get_static_pad(mainbin[elemId].gst, change_pad_name);
+	sinkpad = gst_element_get_static_pad(mainbin[elem_idx].gst, change_pad_name);
 	if (sinkpad == NULL) {
 		LOGD("sinkpad is NULL");
 		result = MM_ERROR_PLAYER_INTERNAL;
@@ -8688,7 +8665,7 @@ __mmplayer_change_selector_pad(mm_player_t* player, MMPlayerTrackType type, int
 	}
 
 	LOGD("Set Active Pad - %s:%s\n", GST_DEBUG_PAD_NAME(sinkpad));
-	g_object_set(mainbin[elemId].gst, "active-pad", sinkpad, NULL);
+	g_object_set(mainbin[elem_idx].gst, "active-pad", sinkpad, NULL);
 
 	caps = gst_pad_get_current_caps(sinkpad);
 	MMPLAYER_LOG_GST_CAPS_TYPE(caps);