From: Hyunil Date: Wed, 14 Feb 2018 07:29:04 +0000 (+0900) Subject: Change the location of variable declarations and add dlog for call stack X-Git-Tag: submit/tizen/20180305.045352~4 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=95071b0dc7e2841f1284f822de8d8c3a03bc496b;p=platform%2Fcore%2Fapi%2Fmediastreamer.git Change the location of variable declarations and add dlog for call stack Change-Id: I38a61bbbbf2e6483a17ed811c320c1337511bbc9 Signed-off-by: Hyunil --- diff --git a/src/media_streamer_gst.c b/src/media_streamer_gst.c index 502ec4e..d323c5f 100644 --- a/src/media_streamer_gst.c +++ b/src/media_streamer_gst.c @@ -51,9 +51,13 @@ void __ms_generate_dots(GstElement *bin, gchar *name_tag) static int __ms_add_no_target_ghostpad(GstElement *gst_bin, const char *ghost_pad_name, GstPadDirection pad_direction) { int ret = MEDIA_STREAMER_ERROR_NONE; + gchar *bin_name = NULL; + GstPad *ghost_pad = NULL; + + ms_debug_fenter(); - gchar *bin_name = gst_element_get_name(gst_bin); - GstPad *ghost_pad = gst_ghost_pad_new_no_target(ghost_pad_name, pad_direction); + bin_name = gst_element_get_name(gst_bin); + ghost_pad = gst_ghost_pad_new_no_target(ghost_pad_name, pad_direction); if (gst_element_add_pad(GST_ELEMENT(gst_bin), ghost_pad)) { gst_pad_set_active(ghost_pad, TRUE); ms_info("Added [%s] empty ghostpad into [%s]", ghost_pad_name, bin_name); @@ -63,17 +67,23 @@ static int __ms_add_no_target_ghostpad(GstElement *gst_bin, const char *ghost_pa } MS_SAFE_GFREE(bin_name); + + ms_debug_fleave(); + return ret; } static gboolean __ms_add_ghostpad(GstElement *gst_element, const char *pad_name, GstElement *gst_bin, const char *ghost_pad_name) { - ms_retvm_if(!gst_element || !pad_name || !ghost_pad_name || !gst_bin, FALSE, "Handle is NULL"); - gboolean ret = FALSE; - GstPad *ghost_pad = NULL; - GstPad *element_pad = gst_element_get_static_pad(gst_element, pad_name); + GstPad *element_pad = NULL; + + ms_debug_fenter(); + + ms_retvm_if(!gst_element || !pad_name || !ghost_pad_name || !gst_bin, FALSE, "Handle is NULL"); + + element_pad = gst_element_get_static_pad(gst_element, pad_name); /* Check, if pad is not static, get it by request */ if (element_pad == NULL) @@ -90,17 +100,24 @@ static gboolean __ms_add_ghostpad(GstElement *gst_element, const char *pad_name, ms_error("Error: element [%s] does not have valid [%s] pad for adding into [%s] bin", GST_ELEMENT_NAME(gst_element), pad_name, GST_ELEMENT_NAME(gst_bin)); MS_SAFE_UNREF(element_pad); + + ms_debug_fleave(); + return ret; } /* This unlinks from its peer and ghostpads on its way */ static gboolean __ms_pad_peer_unlink(GstPad *pad) { + gboolean ret = TRUE; + GstPad *peer_pad = NULL; + + ms_debug_fenter(); + if (!gst_pad_is_linked(pad)) return TRUE; - gboolean ret = TRUE; - GstPad *peer_pad = gst_pad_get_peer(pad); + peer_pad = gst_pad_get_peer(pad); ms_retvm_if(!peer_pad, FALSE, "Fail to get peer pad"); if (GST_IS_PROXY_PAD(peer_pad)) { @@ -135,20 +152,27 @@ static gboolean __ms_pad_peer_unlink(GstPad *pad) MS_SAFE_UNREF(peer_pad); + ms_debug_fleave(); + return ret; } static GstElement *__ms_pad_get_peer_element(GstPad *pad) { + GstPad *peer_pad = NULL; + GstElement *ret = NULL; + + ms_debug_fenter(); + if (!gst_pad_is_linked(pad)) { ms_info("Pad [%s:%s] is not linked yet", GST_DEBUG_PAD_NAME(pad)); return NULL; } - GstPad *peer_pad = gst_pad_get_peer(pad); + peer_pad = gst_pad_get_peer(pad); ms_retvm_if(!peer_pad, FALSE, "Fail to get peer pad"); - GstElement *ret = gst_pad_get_parent_element(peer_pad); + ret = gst_pad_get_parent_element(peer_pad); if (!ret) { if (GST_IS_PROXY_PAD(peer_pad)) { GstPad *ghost_pad = GST_PAD(gst_pad_get_parent(peer_pad)); @@ -174,6 +198,9 @@ static GstElement *__ms_pad_get_peer_element(GstPad *pad) } } MS_SAFE_UNREF(peer_pad); + + ms_debug_fleave(); + return ret; } @@ -182,8 +209,11 @@ gboolean __ms_element_unlink(GstElement *element) gboolean ret = TRUE; GstPad *pad = NULL; GValue elem = G_VALUE_INIT; + GstIterator *pad_iterator = NULL; - GstIterator *pad_iterator = gst_element_iterate_pads(element); + ms_debug_fenter(); + + pad_iterator = gst_element_iterate_pads(element); while (GST_ITERATOR_OK == gst_iterator_next(pad_iterator, &elem)) { pad = (GstPad *) g_value_get_object(&elem); ret = ret && __ms_pad_peer_unlink(pad); @@ -192,14 +222,20 @@ gboolean __ms_element_unlink(GstElement *element) g_value_unset(&elem); gst_iterator_free(pad_iterator); + ms_debug_fleave(); + return ret; } gboolean __ms_bin_remove_element(GstElement *element) { - GstElement *parent = (GstElement *) gst_element_get_parent(element); + GstElement *parent = NULL; gboolean ret = FALSE; + ms_debug_fenter(); + + parent = (GstElement *) gst_element_get_parent(element); + /* Remove node's element from bin that decreases ref count */ if (parent != NULL) { ret = gst_bin_remove(GST_BIN(parent), element); @@ -208,14 +244,21 @@ gboolean __ms_bin_remove_element(GstElement *element) } MS_SAFE_UNREF(parent); + + ms_debug_fleave(); + return ret; } gboolean __ms_bin_add_element(GstElement *bin, GstElement *element, gboolean do_ref) { - GstElement *parent = (GstElement *) gst_element_get_parent(element); + GstElement *parent = NULL; gboolean ret = FALSE; + ms_debug_fenter(); + + parent = (GstElement *) gst_element_get_parent(element); + /* Add node's element into bin and increases ref count if needed */ if (parent == NULL) { ret = gst_bin_add(GST_BIN(bin), element); @@ -226,15 +269,25 @@ gboolean __ms_bin_add_element(GstElement *bin, GstElement *element, gboolean do_ } MS_SAFE_UNREF(parent); + + ms_debug_fleave(); + return ret; } const gchar *__ms_get_pad_type(GstPad *element_pad) { const gchar *pad_type = NULL; - GstCaps *pad_caps = gst_pad_query_caps(element_pad, 0); + GstCaps *pad_caps = NULL; + + ms_debug_fenter(); + + pad_caps = gst_pad_query_caps(element_pad, 0); MS_GET_CAPS_TYPE(pad_caps, pad_type); gst_caps_unref(pad_caps); + + ms_debug_fleave(); + return pad_type; } @@ -245,6 +298,8 @@ static GstElement *__ms_find_peer_element_by_type(GstElement *previous_element, GValue src_pad_value = G_VALUE_INIT; const gchar *found_klass = NULL; + ms_debug_fenter(); + if (prev_elem_src_pad) { /* Check if previous element`s source pad is connected with element */ @@ -281,6 +336,8 @@ static GstElement *__ms_find_peer_element_by_type(GstElement *previous_element, if (!peer_element) ms_info(" Element [%s] is not connected", GST_ELEMENT_NAME(previous_element)); + ms_debug_fleave(); + return peer_element; } @@ -289,9 +346,14 @@ gboolean __ms_link_two_elements(GstElement *previous_element, GstPad *prev_elem_ GValue src_pad_value = G_VALUE_INIT; gboolean elements_linked = FALSE; GstPad * found_sink_pad = NULL; + GstElement *peer_element = NULL; + GstIterator *src_pad_iterator = NULL; + GstPad *src_pad = NULL; + + ms_debug_fenter(); if (prev_elem_src_pad) { - GstElement *peer_element = __ms_pad_get_peer_element(prev_elem_src_pad); + peer_element = __ms_pad_get_peer_element(prev_elem_src_pad); if (!gst_pad_is_linked(prev_elem_src_pad)) { /* Check compatibility of previous element and unlinked found element */ @@ -305,9 +367,9 @@ gboolean __ms_link_two_elements(GstElement *previous_element, GstPad *prev_elem_ } else { /* Check if previous element has any unlinked src pad */ - GstIterator *src_pad_iterator = gst_element_iterate_src_pads(previous_element); + src_pad_iterator = gst_element_iterate_src_pads(previous_element); while (GST_ITERATOR_OK == gst_iterator_next(src_pad_iterator, &src_pad_value)) { - GstPad *src_pad = (GstPad *) g_value_get_object(&src_pad_value); + src_pad = (GstPad *) g_value_get_object(&src_pad_value); GstElement *peer_element = __ms_pad_get_peer_element(src_pad); if (!gst_pad_is_linked(src_pad)) { @@ -340,6 +402,9 @@ gboolean __ms_link_two_elements(GstElement *previous_element, GstPad *prev_elem_ ms_info("Element [%s] has no free compatible pad to be connected with [%s] or linked", GST_ELEMENT_NAME(found_element), GST_ELEMENT_NAME(previous_element)); MS_SAFE_UNREF(found_sink_pad); + + ms_debug_fleave(); + return elements_linked; } @@ -348,11 +413,14 @@ static GstElement *__ms_bin_find_element_by_type(GstElement *previous_element, G GValue element_value = G_VALUE_INIT; GstElement *found_element = NULL; gboolean elements_linked = FALSE; + const gchar *found_klass = NULL; + + ms_debug_fenter(); GstIterator *bin_iterator = gst_bin_iterate_sorted(GST_BIN(search_bin)); while (GST_ITERATOR_OK == gst_iterator_next(bin_iterator, &element_value)) { found_element = (GstElement *) g_value_get_object(&element_value); - const gchar *found_klass = gst_element_factory_get_klass(gst_element_get_factory(found_element)); + found_klass = gst_element_factory_get_klass(gst_element_get_factory(found_element)); /* Check if found element is of appropriate needed plugin class */ if (g_strrstr(found_klass, node_klass_type->klass_name) || g_strrstr(GST_ELEMENT_NAME(found_element), node_klass_type->default_name)) { @@ -369,22 +437,30 @@ static GstElement *__ms_bin_find_element_by_type(GstElement *previous_element, G g_value_unset(&element_value); gst_iterator_free(bin_iterator); + ms_debug_fleave(); + return elements_linked ? found_element : NULL; } int __ms_factory_rank_compare(GstPluginFeature * first_feature, GstPluginFeature * second_feature) { + ms_debug_fenter(); + ms_debug_fleave(); return (gst_plugin_feature_get_rank(second_feature) - gst_plugin_feature_get_rank(first_feature)); } GstElement *__ms_combine_next_element(GstElement *previous_element, GstPad *prev_elem_src_pad, GstElement *bin_to_find_in, media_streamer_node_type_e node_type) { + GstCaps *prev_caps = NULL; + GstElement *found_element = NULL; + node_info_s *node_klass_type = NULL; + + ms_debug_fenter(); + if (!previous_element) return NULL; - GstCaps *prev_caps = NULL; - GstElement *found_element = NULL; - node_info_s *node_klass_type = __ms_node_get_klass_by_its_type(node_type); + node_klass_type = __ms_node_get_klass_by_its_type(node_type); /* - 1 - If previous element is linked - check for peer element */ found_element = __ms_find_peer_element_by_type(GST_ELEMENT(previous_element), prev_elem_src_pad, node_klass_type); @@ -428,6 +504,8 @@ GstElement *__ms_combine_next_element(GstElement *previous_element, GstPad *prev MS_SAFE_UNREF(previous_element); + ms_debug_fleave(); + return found_element; } @@ -439,14 +517,16 @@ static gint __decodebin_autoplug_select_cb(GstElement * bin, GstPad * pad, GstCa GST_AUTOPLUG_SELECT_EXPOSE, GST_AUTOPLUG_SELECT_SKIP } GstAutoplugSelectResult; - - media_streamer_s *ms_streamer = (media_streamer_s *) data; - ms_retvm_if(!ms_streamer, GST_AUTOPLUG_SELECT_TRY, "Handle is NULL"); - + media_streamer_s *ms_streamer = NULL; gchar *factory_name = NULL; const gchar *klass = NULL; GstAutoplugSelectResult result = GST_AUTOPLUG_SELECT_TRY; + ms_debug_fenter(); + + ms_streamer = (media_streamer_s *) data; + ms_retvm_if(!ms_streamer, GST_AUTOPLUG_SELECT_TRY, "Handle is NULL"); + factory_name = GST_OBJECT_NAME(factory); klass = gst_element_factory_get_metadata(factory, GST_ELEMENT_METADATA_KLASS); @@ -459,6 +539,8 @@ static gint __decodebin_autoplug_select_cb(GstElement * bin, GstPad * pad, GstCa for ( ; ms_streamer->ini.exclude_elem_names[index]; ++index) { if (g_strrstr(factory_name, ms_streamer->ini.exclude_elem_names[index])) { ms_debug("Decodebin: skipping [%s] as excluded", factory_name); + ms_debug_fleave(); + return GST_AUTOPLUG_SELECT_SKIP; } } @@ -497,16 +579,27 @@ static gint __decodebin_autoplug_select_cb(GstElement * bin, GstPad * pad, GstCa } } + ms_debug_fleave(); + return result; } static gint __pad_type_compare(gconstpointer a, gconstpointer b) { - GstPad *a_pad = GST_PAD(a); - GstPad *b_pad = GST_PAD(b); + GstPad *a_pad = NULL; + GstPad *b_pad = NULL; + const gchar *a_pad_type = NULL; + const gchar *b_pad_type = NULL; + + ms_debug_fenter(); + + a_pad = GST_PAD(a); + b_pad = GST_PAD(b); + + a_pad_type = __ms_get_pad_type(a_pad); + b_pad_type = __ms_get_pad_type(b_pad); - const gchar *a_pad_type = __ms_get_pad_type(a_pad); - const gchar *b_pad_type = __ms_get_pad_type(b_pad); + ms_debug_fleave(); if (MS_ELEMENT_IS_TEXT(a_pad_type)) return -1; @@ -518,7 +611,11 @@ static gint __pad_type_compare(gconstpointer a, gconstpointer b) static void __decodebin_newpad_cb(GstElement * decodebin, GstPad * new_pad, gpointer user_data) { - media_streamer_s *ms_streamer = (media_streamer_s *) user_data; + media_streamer_s *ms_streamer = NULL; + + ms_debug_fenter(); + + ms_streamer = (media_streamer_s *) user_data; ms_retm_if(ms_streamer == NULL, "Handle is NULL"); g_mutex_lock(&ms_streamer->mutex_lock); @@ -527,12 +624,19 @@ static void __decodebin_newpad_cb(GstElement * decodebin, GstPad * new_pad, gpoi ms_streamer->pads_types_list = g_list_insert_sorted(ms_streamer->pads_types_list, new_pad, __pad_type_compare); g_mutex_unlock(&ms_streamer->mutex_lock); + + ms_debug_fleave(); } static void __decodebin_nomore_pads_combine(GstPad *src_pad, media_streamer_s *ms_streamer, media_streamer_sink_bin_type_e sink_bin_type) { - GstElement *found_element = gst_pad_get_parent_element(src_pad); - const gchar *new_pad_type = __ms_get_pad_type(src_pad); + GstElement *found_element = NULL; + const gchar *new_pad_type = NULL; + + ms_debug_fenter(); + + found_element = gst_pad_get_parent_element(src_pad); + new_pad_type = __ms_get_pad_type(src_pad); if (MS_ELEMENT_IS_VIDEO(new_pad_type)) { if (__ms_bin_find_element_by_type(found_element, src_pad, ms_streamer->transform_bin, __ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_TEXT_OVERLAY))) { @@ -571,21 +675,33 @@ static void __decodebin_nomore_pads_combine(GstPad *src_pad, media_streamer_s *m __ms_generate_dots(ms_streamer->pipeline, "after_sink_linked"); gst_object_unref(found_element); + + ms_debug_fleave(); } static void __decodebin_nomore_pads_cb(GstElement *decodebin, gpointer user_data) { - media_streamer_s *ms_streamer = (media_streamer_s *) user_data; + media_streamer_s *ms_streamer = NULL; + media_streamer_sink_bin_type_e sink_bin_type = MEDIA_STREAMER_SINK_BIN_NORMAL; + media_streamer_node_s *rtp_node = NULL; + media_streamer_node_s *adaptive_sink = NULL; + char *decodebin_name = NULL; + char *param_value = NULL; + GList *iterator = NULL; + GList *list = NULL; + GstPad *src_pad = NULL; + + ms_debug_fenter(); + + ms_streamer = (media_streamer_s *) user_data; ms_retm_if(ms_streamer == NULL, "Handle is NULL"); g_mutex_lock(&ms_streamer->mutex_lock); - media_streamer_sink_bin_type_e sink_bin_type = MEDIA_STREAMER_SINK_BIN_NORMAL; - media_streamer_node_s *rtp_node = (media_streamer_node_s *)g_hash_table_lookup(ms_streamer->nodes_table, "rtp_container"); - media_streamer_node_s *adaptive_sink = (media_streamer_node_s *)g_hash_table_lookup(ms_streamer->nodes_table, "adaptive_sink"); + rtp_node = (media_streamer_node_s *)g_hash_table_lookup(ms_streamer->nodes_table, "rtp_container"); + adaptive_sink = (media_streamer_node_s *)g_hash_table_lookup(ms_streamer->nodes_table, "adaptive_sink"); if (rtp_node) { - char *decodebin_name = NULL; g_object_get(G_OBJECT(decodebin), "name", &decodebin_name, NULL); /* FIXME: This case may be not general */ @@ -594,7 +710,6 @@ static void __decodebin_nomore_pads_cb(GstElement *decodebin, gpointer user_data MS_SAFE_FREE(decodebin_name); } else { /* It`s server part of Streaming Scenario*/ - char *param_value = NULL; media_streamer_node_get_param(rtp_node, MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT, ¶m_value); if (param_value && (strtol(param_value, NULL, 10) > 0)) sink_bin_type = MEDIA_STREAMER_SINK_BIN_RTP_SERVER; @@ -606,21 +721,27 @@ static void __decodebin_nomore_pads_cb(GstElement *decodebin, gpointer user_data sink_bin_type = MEDIA_STREAMER_SINK_BIN_ADAPTIVE; } - GList *iterator = NULL; - GList *list = ms_streamer->pads_types_list; + iterator = NULL; + list = ms_streamer->pads_types_list; for (iterator = list; iterator; iterator = iterator->next) { - GstPad *src_pad = GST_PAD(iterator->data); + src_pad = GST_PAD(iterator->data); __decodebin_nomore_pads_combine(src_pad, ms_streamer, sink_bin_type); } g_mutex_unlock(&ms_streamer->mutex_lock); + + ms_debug_fleave(); } GstElement *__ms_decodebin_create(media_streamer_s * ms_streamer, char * name) { + GstElement *decodebin = NULL; + + ms_debug_fenter(); + ms_retvm_if(!ms_streamer, NULL, "Handle is NULL"); - GstElement *decodebin = __ms_element_create(DEFAULT_DECODEBIN, name); + decodebin = __ms_element_create(DEFAULT_DECODEBIN, name); __ms_bin_add_element(ms_streamer->transform_bin, decodebin, TRUE); gst_element_sync_state_with_parent(decodebin); @@ -628,6 +749,8 @@ GstElement *__ms_decodebin_create(media_streamer_s * ms_streamer, char * name) __ms_signal_create(&ms_streamer->autoplug_sig_list, decodebin, "autoplug-select", G_CALLBACK(__decodebin_autoplug_select_cb), ms_streamer); __ms_signal_create(&ms_streamer->autoplug_sig_list, decodebin, "no-more-pads", G_CALLBACK(__decodebin_nomore_pads_cb), ms_streamer); + ms_debug_fleave(); + return decodebin; } @@ -635,9 +758,12 @@ static gboolean __ms_sink_bin_prepare(media_streamer_s * ms_streamer, GstPad * s { GstElement *decoder_element = NULL; GstElement *found_element = NULL; + GstElement *parent_rtp_element = NULL; + + ms_debug_fenter(); /* Getting Depayloader */ - GstElement *parent_rtp_element = gst_pad_get_parent_element(source_pad); + parent_rtp_element = gst_pad_get_parent_element(source_pad); if (MS_ELEMENT_IS_VIDEO(src_pad_type)) { gst_object_ref(parent_rtp_element); @@ -650,6 +776,9 @@ static gboolean __ms_sink_bin_prepare(media_streamer_s * ms_streamer, GstPad * s gst_object_ref(found_element); __ms_link_two_elements(found_element, NULL, decoder_element); MS_SAFE_UNREF(decoder_element); + + ms_debug_fleave(); + return TRUE; } else { gst_object_ref(found_element); @@ -671,14 +800,20 @@ static gboolean __ms_sink_bin_prepare(media_streamer_s * ms_streamer, GstPad * s MS_SAFE_UNREF(found_element); MS_SAFE_UNREF(parent_rtp_element); + ms_debug_fleave(); + return TRUE; } static void __ms_rtpbin_pad_added_cb(GstElement * src, GstPad * new_pad, gpointer user_data) { + media_streamer_node_s *ms_node = NULL; + + ms_debug_fenter(); + ms_debug("Pad [%s] added on [%s]", GST_PAD_NAME(new_pad), GST_ELEMENT_NAME(src)); - media_streamer_node_s *ms_node = (media_streamer_node_s *) user_data; + ms_node = (media_streamer_node_s *) user_data; ms_retm_if(ms_node == NULL, "Handle is NULL"); if (g_str_has_prefix(GST_PAD_NAME(new_pad), "recv_rtp_src")) { @@ -721,37 +856,58 @@ static void __ms_rtpbin_pad_added_cb(GstElement * src, GstPad * new_pad, gpointe gst_caps_unref(src_pad_caps); MS_SAFE_UNREF(target_pad); } + + ms_debug_fleave(); } int __ms_element_set_state(GstElement * gst_element, GstState gst_state) { - ms_retvm_if(gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - GstStateChangeReturn ret_state; + ms_debug_fenter(); + + ms_retvm_if(gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); + ret_state = gst_element_set_state(gst_element, gst_state); + if (ret_state == GST_STATE_CHANGE_FAILURE) { ms_error("Failed to set element [%s] into %s state", GST_ELEMENT_NAME(gst_element), gst_element_state_get_name(gst_state)); return MEDIA_STREAMER_ERROR_INVALID_OPERATION; } + ms_debug_fleave(); + return MEDIA_STREAMER_ERROR_NONE; } GstElement *__ms_element_create(const char *plugin_name, const char *name) { GstElement *plugin_elem = NULL; + + ms_debug_fenter(); + ms_retvm_if(plugin_name == NULL, (GstElement *) NULL, "Error empty plugin name"); + ms_info("Creating [%s] element", plugin_name); + plugin_elem = gst_element_factory_make(plugin_name, name); ms_retvm_if(plugin_elem == NULL, (GstElement *) NULL, "Error creating element [%s]", plugin_name); + + ms_debug_fleave(); + return plugin_elem; } static void __hlsdemux_pad_added_cb(GstElement *demux, GstPad *pad, gpointer data) { - GstPad *gp = GST_PAD(data); + GstPad *gp = NULL; + + ms_debug_fenter(); + + gp = GST_PAD(data); gst_ghost_pad_set_target(GST_GHOST_PAD(gp), pad); + + ms_debug_fleave(); } static int __ms_adaptive_sink_prepare(media_streamer_s * ms_streamer) @@ -761,20 +917,38 @@ static int __ms_adaptive_sink_prepare(media_streamer_s * ms_streamer) {"Codec/Encoder/Audio", "audio_encoder"}, /* MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER */ {"Codec/Muxer", "mpegtsmux"}, /* MEDIA_STREAMER_NODE_TYPE_MUXER */ }; - - GstCaps *video_enc_src_caps = gst_caps_new_simple("video/mpeg", "mpegversion", G_TYPE_INT, 4, NULL); - GstCaps *video_enc_sink_caps = gst_caps_new_empty_simple("video/x-raw"); - node_plug_s video_enc_plug_info = {&(nodes_info[0]), video_enc_src_caps, video_enc_sink_caps, NULL}; - GstElement *video_enc = __ms_node_element_create(&video_enc_plug_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER); - - GstCaps *audio_enc_src_caps = gst_caps_new_simple("audio/mpeg", "mpegversion", G_TYPE_INT, 4, NULL); - GstCaps *audio_enc_sink_caps = gst_caps_new_empty_simple("audio/x-raw"); - node_plug_s audio_enc_plug_info = {&(nodes_info[1]), audio_enc_src_caps, audio_enc_sink_caps, NULL}; - GstElement *audio_enc = __ms_node_element_create(&audio_enc_plug_info, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER); - - GstCaps *muxer_src_caps = gst_caps_new_empty_simple("video/mpegts"); - node_plug_s mux_plug_info = {&(nodes_info[2]), muxer_src_caps, NULL, NULL}; - GstElement *muxer = __ms_node_element_create(&mux_plug_info, MEDIA_STREAMER_NODE_TYPE_MUXER); + GstCaps *video_enc_src_caps = NULL; + GstCaps *video_enc_sink_caps = NULL; + GstCaps *audio_enc_src_caps = NULL; + GstCaps *audio_enc_sink_caps = NULL; + GstElement *audio_enc = NULL; + GstElement *video_enc = NULL; + GstCaps *muxer_src_caps = NULL; + GstElement *muxer = NULL; + node_plug_s video_enc_plug_info = {0, }; + node_plug_s audio_enc_plug_info = {0, }; + node_plug_s mux_plug_info = {0, }; + + ms_debug_fenter(); + + video_enc_src_caps = gst_caps_new_simple("video/mpeg", "mpegversion", G_TYPE_INT, 4, NULL); + video_enc_sink_caps = gst_caps_new_empty_simple("video/x-raw"); + video_enc_plug_info.info = &(nodes_info[0]); + video_enc_plug_info.src_caps = video_enc_src_caps; + video_enc_plug_info.sink_caps = video_enc_sink_caps; + video_enc = __ms_node_element_create(&video_enc_plug_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER); + + audio_enc_src_caps = gst_caps_new_simple("audio/mpeg", "mpegversion", G_TYPE_INT, 4, NULL); + audio_enc_sink_caps = gst_caps_new_empty_simple("audio/x-raw"); + audio_enc_plug_info.info = &(nodes_info[1]); + audio_enc_plug_info.src_caps = audio_enc_src_caps; + audio_enc_plug_info.sink_caps = audio_enc_sink_caps; + audio_enc = __ms_node_element_create(&audio_enc_plug_info, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER); + + muxer_src_caps = gst_caps_new_empty_simple("video/mpegts"); + mux_plug_info.info = &(nodes_info[2]); + mux_plug_info.src_caps = muxer_src_caps; + muxer = __ms_node_element_create(&mux_plug_info, MEDIA_STREAMER_NODE_TYPE_MUXER); __ms_bin_add_element(ms_streamer->transform_bin, muxer, FALSE); gst_element_sync_state_with_parent(muxer); @@ -783,12 +957,18 @@ static int __ms_adaptive_sink_prepare(media_streamer_s * ms_streamer) __ms_bin_add_element(ms_streamer->transform_bin, audio_enc, FALSE); gst_element_sync_state_with_parent(audio_enc); + ms_debug_fleave(); + return MEDIA_STREAMER_ERROR_NONE; } GstElement *__ms_adaptive_element_create(void) { - GstElement *adaptive_bin = gst_bin_new("adaptive_src"); + GstElement *adaptive_bin = NULL; + + ms_debug_fenter(); + + adaptive_bin = gst_bin_new("adaptive_src"); ms_retvm_if(!adaptive_bin, (GstElement *) NULL, "Error: creating elements for adaptive source"); __ms_add_no_target_ghostpad(adaptive_bin, "src", GST_PAD_SRC); @@ -796,6 +976,8 @@ GstElement *__ms_adaptive_element_create(void) /* Add adaptive node parameters as GObject data with destroy function */ MS_SET_INT_STATIC_STRING_PARAM(adaptive_bin, MEDIA_STREAMER_PARAM_URI, "http://localhost"); + ms_debug_fleave(); + return adaptive_bin; } @@ -804,10 +986,15 @@ static GstElement *__ms_manifest_src_create(media_streamer_node_s *ms_node) char *manifest_src_name = NULL; gchar *location = NULL; GstElement *manifest_src = NULL; + GValue *val = NULL; + const char *uri = NULL; + gchar *protocol = NULL; + + ms_debug_fenter(); - GValue *val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_URI); - const char *uri = g_value_get_string(val); - gchar *protocol = gst_uri_is_valid(uri) ? gst_uri_get_protocol(uri) : NULL; + val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_URI); + uri = g_value_get_string(val); + protocol = gst_uri_is_valid(uri) ? gst_uri_get_protocol(uri) : NULL; if (protocol && g_strrstr(protocol, "http")) { manifest_src_name = __ms_ini_get_string("node type 1:http", DEFAULT_HTTP_SOURCE); @@ -846,6 +1033,8 @@ static GstElement *__ms_manifest_src_create(media_streamer_node_s *ms_node) g_object_set(manifest_src, "location", location, NULL); g_free(location); + ms_debug_fleave(); + return manifest_src; } @@ -857,6 +1046,8 @@ int __ms_adaptive_element_prepare(media_streamer_node_s *ms_node, bool auto_plug gboolean res = FALSE; GstPad *gp = NULL; + ms_debug_fenter(); + ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); if (!auto_plug) { @@ -899,21 +1090,29 @@ int __ms_adaptive_element_prepare(media_streamer_node_s *ms_node, bool auto_plug gst_ghost_pad_set_target(GST_GHOST_PAD(gp), manifest_src_pad); } + ms_debug_fleave(); + return MEDIA_STREAMER_ERROR_NONE; } static gboolean __ms_feature_node_filter(GstPluginFeature *feature, gpointer data) { - node_plug_s *plug_info = (node_plug_s*)data; + node_plug_s *plug_info = NULL; + gboolean can_accept = FALSE; + gboolean src_can_accept = FALSE; + gboolean sink_can_accept = FALSE; + GstElementFactory *factory = NULL; + const gchar *factory_klass = NULL; + + ms_debug_fenter(); + + plug_info = (node_plug_s*)data; if (!GST_IS_ELEMENT_FACTORY(feature)) return FALSE; - gboolean can_accept = FALSE; - gboolean src_can_accept = FALSE; - gboolean sink_can_accept = FALSE; - GstElementFactory *factory = GST_ELEMENT_FACTORY(feature); - const gchar *factory_klass = gst_element_factory_get_klass(factory); + factory = GST_ELEMENT_FACTORY(feature); + factory_klass = gst_element_factory_get_klass(factory); if (plug_info && g_strrstr(factory_klass, plug_info->info->klass_name)) { if (GST_IS_CAPS(plug_info->src_caps)) @@ -944,6 +1143,8 @@ static gboolean __ms_feature_node_filter(GstPluginFeature *feature, gpointer dat } + ms_debug_fleave(); + return FALSE; } @@ -951,13 +1152,16 @@ static GstElement *__ms_element_create_from_ini(node_plug_s *plug_info, media_st { const gchar *src_type, *sink_type; const gchar *format_type; + GstElement *gst_element = NULL; + gchar conf_key[INI_MAX_STRLEN] = {0,}; + gchar *plugin_name = NULL; + + ms_debug_fenter(); MS_GET_CAPS_TYPE(plug_info->src_caps, src_type); MS_GET_CAPS_TYPE(plug_info->sink_caps, sink_type); - GstElement *gst_element = NULL; ms_info("Specified node formats types: in[%s] - out[%s]", sink_type, src_type); - gchar conf_key[INI_MAX_STRLEN] = {0,}; if (type == MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER) { format_type = src_type; @@ -982,30 +1186,40 @@ static GstElement *__ms_element_create_from_ini(node_plug_s *plug_info, media_st ms_error("Failed to generate config field name, size >= %d", INI_MAX_STRLEN); return NULL; } - gchar *plugin_name = __ms_ini_get_string(conf_key, NULL); + + plugin_name = __ms_ini_get_string(conf_key, NULL); if (plugin_name) { gst_element = __ms_element_create(plugin_name, NULL); MS_SAFE_GFREE(plugin_name); } + + ms_debug_fleave(); + return gst_element; } static GstElement *__ms_element_create_by_registry(node_plug_s *plug_info, media_streamer_node_type_e type) { GstElement *gst_element = NULL; - const gchar *src_type, *sink_type; + const gchar *src_type = NULL; + const gchar *sink_type = NULL; + GList *factories = NULL; + GstElementFactory *factory = NULL; + + ms_debug_fenter(); + MS_GET_CAPS_TYPE(plug_info->src_caps, src_type); MS_GET_CAPS_TYPE(plug_info->sink_caps, sink_type); __ms_ini_read_list("general:exclude elements", &plug_info->exclude_names); - GList *factories = gst_registry_feature_filter(gst_registry_get(), + factories = gst_registry_feature_filter(gst_registry_get(), __ms_feature_node_filter, FALSE, plug_info); factories = g_list_sort(factories, (GCompareFunc) __ms_factory_rank_compare); if (factories) { - GstElementFactory *factory = GST_ELEMENT_FACTORY(factories->data); + factory = GST_ELEMENT_FACTORY(factories->data); gst_element = __ms_element_create(GST_OBJECT_NAME(factory), NULL); } else { ms_debug("Could not find any compatible element for node [%d]: in[%s] - out[%s]", @@ -1015,14 +1229,18 @@ static GstElement *__ms_element_create_by_registry(node_plug_s *plug_info, media g_strfreev(plug_info->exclude_names); gst_plugin_list_free(factories); + ms_debug_fleave(); + return gst_element; } GstElement *__ms_node_element_create(node_plug_s *plug_info, media_streamer_node_type_e type) { GstElement *gst_element = NULL; + const gchar *src_type = NULL; + const gchar *sink_type = NULL; - const gchar *src_type, *sink_type; + ms_debug_fenter(); MS_GET_CAPS_TYPE(plug_info->src_caps, src_type); MS_GET_CAPS_TYPE(plug_info->sink_caps, sink_type); @@ -1060,6 +1278,8 @@ GstElement *__ms_node_element_create(node_plug_s *plug_info, media_streamer_node gst_element = __ms_element_create_by_registry(plug_info, type); } + ms_debug_fleave(); + return gst_element; } @@ -1076,8 +1296,11 @@ GstElement *__ms_video_encoder_element_create(node_plug_s *plug_info, media_stre node_plug_s parser_info = {0,}; node_info_s node_info = {MEDIA_STREAMER_PARSER_KLASS, DEFAULT_VIDEO_PARSER}; media_format_mimetype_e encoder_type = MEDIA_FORMAT_MAX; + GstCaps *enc_caps = NULL; + + ms_debug_fenter(); - GstCaps *enc_caps = plug_info->src_caps; + enc_caps = plug_info->src_caps; if (!enc_caps) { enc_caps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_VIDEO_FORMAT); ms_debug("No Video encoding format is set! Deafault will be: [%s]", MEDIA_STREAMER_DEFAULT_VIDEO_FORMAT); @@ -1138,6 +1361,8 @@ GstElement *__ms_video_encoder_element_create(node_plug_s *plug_info, media_stre __ms_add_ghostpad(encoder_parser, "src", encoder_bin, "src"); __ms_add_ghostpad(video_convert, "sink", encoder_bin, "sink"); + ms_debug_fleave(); + return encoder_bin; ERROR: @@ -1148,6 +1373,8 @@ ERROR: MS_SAFE_UNREF(encoder_parser); MS_SAFE_UNREF(encoder_bin); + ms_debug_fleave(); + return NULL; } @@ -1167,8 +1394,11 @@ GstElement *__ms_video_decoder_element_create(node_plug_s *plug_info, media_stre media_format_mimetype_e decoder_type = MEDIA_FORMAT_MAX; gboolean gst_ret = FALSE; const gchar *sink_type = NULL; + GstCaps *dec_caps = NULL; - GstCaps *dec_caps = plug_info->sink_caps; + ms_debug_fenter(); + + dec_caps = plug_info->sink_caps; if (!dec_caps) { dec_caps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_VIDEO_FORMAT); ms_debug("No Video decoding format is set! Deafault will be: [%s]", MEDIA_STREAMER_DEFAULT_VIDEO_FORMAT); @@ -1220,6 +1450,7 @@ GstElement *__ms_video_decoder_element_create(node_plug_s *plug_info, media_stre MS_SAFE_UNREF(decoder_bin); return NULL; } + last_elem = decoder_elem; if (!is_hw_codec) { @@ -1243,6 +1474,8 @@ GstElement *__ms_video_decoder_element_create(node_plug_s *plug_info, media_stre __ms_add_ghostpad(last_elem, "src", decoder_bin, "src"); __ms_add_ghostpad(decoder_queue, "sink", decoder_bin, "sink"); + ms_debug_fleave(); + return decoder_bin; ERROR: @@ -1254,6 +1487,8 @@ ERROR: MS_SAFE_UNREF(video_scale); MS_SAFE_UNREF(decoder_bin); + ms_debug_fleave(); + return NULL; } @@ -1269,8 +1504,11 @@ GstElement *__ms_audio_encoder_element_create(node_plug_s *plug_info, media_stre node_plug_s plug_info_encoder = {0,}; gchar *encoder_name = NULL; GstCaps *audioCaps = NULL; + GstCaps *enc_caps = NULL; + + ms_debug_fenter(); - GstCaps *enc_caps = plug_info->src_caps; + enc_caps = plug_info->src_caps; if (!enc_caps) { enc_caps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_AUDIO_FORMAT); ms_debug("No Audio encoding format is set! Deafault will be: [%s]", MEDIA_STREAMER_DEFAULT_AUDIO_FORMAT); @@ -1319,7 +1557,10 @@ GstElement *__ms_audio_encoder_element_create(node_plug_s *plug_info, media_stre __ms_add_ghostpad(audio_encoder, "src", audio_enc_bin, "src"); __ms_add_ghostpad(audio_convert, "sink", audio_enc_bin, "sink"); + ms_debug_fleave(); + return audio_enc_bin; + ERROR: MS_SAFE_UNREF(audio_convert); @@ -1329,6 +1570,8 @@ ERROR: MS_SAFE_UNREF(audio_encoder); MS_SAFE_UNREF(audio_enc_bin); + ms_debug_fleave(); + return NULL; } @@ -1345,8 +1588,11 @@ GstElement *__ms_audio_decoder_element_create(node_plug_s *plug_info, media_stre node_plug_s decoder_info = {0,}; node_plug_s parser_info = {0,}; node_info_s nodes_info = {MEDIA_STREAMER_PARSER_KLASS, DEFAULT_AUDIO_PARSER}; + GstCaps *dec_caps = NULL; + + ms_debug_fenter(); - GstCaps *dec_caps = plug_info->sink_caps; + dec_caps = plug_info->sink_caps; if (!dec_caps) { dec_caps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_AUDIO_FORMAT); ms_debug("No Audio decoding format is set! Deafault will be: [%s]", MEDIA_STREAMER_DEFAULT_AUDIO_FORMAT); @@ -1407,7 +1653,10 @@ GstElement *__ms_audio_decoder_element_create(node_plug_s *plug_info, media_stre __ms_add_ghostpad(audio_resample, "src", decoder_bin, "src"); __ms_add_ghostpad(decoder_queue, "sink", decoder_bin, "sink"); + ms_debug_fleave(); + return decoder_bin; + ERROR: MS_SAFE_UNREF(decoder_elem); @@ -1417,12 +1666,18 @@ ERROR: MS_SAFE_UNREF(audio_resample); MS_SAFE_UNREF(decoder_bin); + ms_debug_fleave(); + return NULL; } GstElement *__ms_rtp_element_create(void) { - GstElement *rtp_container = gst_bin_new("rtp_container"); + GstElement *rtp_container = NULL; + + ms_debug_fenter(); + + rtp_container = gst_bin_new("rtp_container"); ms_retvm_if(!rtp_container, (GstElement *) NULL, "Error: creating elements for rtp container"); __ms_add_no_target_ghostpad(rtp_container, MS_RTP_PAD_VIDEO_OUT, GST_PAD_SRC); @@ -1442,33 +1697,47 @@ GstElement *__ms_rtp_element_create(void) MS_SET_INT_CAPS_PARAM(rtp_container, MEDIA_STREAMER_PARAM_VIDEO_IN_FORMAT, gst_caps_new_any()); MS_SET_INT_CAPS_PARAM(rtp_container, MEDIA_STREAMER_PARAM_AUDIO_IN_FORMAT, gst_caps_new_any()); + ms_debug_fleave(); + return rtp_container; } gboolean __ms_rtp_element_prepare(media_streamer_node_s *ms_node) { + GstElement *rtpbin = NULL; + gboolean ret = TRUE; + GstElement *rtp_el = NULL; + GstElement *rtcp_el = NULL; + GValue *val = NULL; + const char *host = NULL; + GstElement *video_filter = NULL; + GstCaps *video_caps = NULL; + GstGhostPad *ghost_pad = NULL; + GstElement *audio_filter = NULL; + GstCaps *audio_caps = NULL; + + ms_debug_fenter(); + ms_retvm_if(!ms_node, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Handle is NULL"); - GstElement *rtpbin = __ms_element_create("rtpbin", "rtpbin"); + rtpbin = __ms_element_create("rtpbin", "rtpbin"); ms_retvm_if(!rtpbin, FALSE, "Error: creating elements for rtp container"); if (!__ms_bin_add_element(ms_node->gst_element, rtpbin, FALSE)) { MS_SAFE_UNREF(rtpbin); return FALSE; } - __ms_signal_create(&ms_node->sig_list, rtpbin, "pad-added", G_CALLBACK(__ms_rtpbin_pad_added_cb), ms_node); - gboolean ret = TRUE; - GstElement *rtp_el = NULL; - GstElement *rtcp_el = NULL; + __ms_signal_create(&ms_node->sig_list, rtpbin, "pad-added", G_CALLBACK(__ms_rtpbin_pad_added_cb), ms_node); - GValue *val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_HOST); - const char *host = g_value_get_string(val); + val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_HOST); + host = g_value_get_string(val); val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_VIDEO_IN_PORT); if (g_value_get_int(val) > RTP_STREAM_DISABLED) { rtp_el = __ms_element_create("udpsrc", MS_RTP_PAD_VIDEO_IN"_rtp"); __ms_bin_add_element(ms_node->gst_element, rtp_el, FALSE); + rtcp_el = __ms_element_create("udpsrc", MS_RTP_PAD_VIDEO_IN"_rctp"); __ms_bin_add_element(ms_node->gst_element, rtcp_el, FALSE); @@ -1486,6 +1755,7 @@ gboolean __ms_rtp_element_prepare(media_streamer_node_s *ms_node) if (g_value_get_int(val) > RTP_STREAM_DISABLED) { rtp_el = __ms_element_create("udpsrc", MS_RTP_PAD_AUDIO_IN"_rtp"); __ms_bin_add_element(ms_node->gst_element, rtp_el, FALSE); + rtcp_el = __ms_element_create("udpsrc", MS_RTP_PAD_AUDIO_IN"_rctp"); __ms_bin_add_element(ms_node->gst_element, rtcp_el, FALSE); @@ -1503,17 +1773,20 @@ gboolean __ms_rtp_element_prepare(media_streamer_node_s *ms_node) if (g_value_get_int(val) > RTP_STREAM_DISABLED) { rtp_el = __ms_element_create("udpsink", MS_RTP_PAD_VIDEO_OUT"_rtp"); __ms_bin_add_element(ms_node->gst_element, rtp_el, FALSE); + rtcp_el = __ms_element_create("udpsink", MS_RTP_PAD_VIDEO_OUT"_rctp"); __ms_bin_add_element(ms_node->gst_element, rtcp_el, FALSE); - GstElement *video_filter = __ms_element_create("capsfilter", NULL); + video_filter = __ms_element_create("capsfilter", NULL); __ms_bin_add_element(ms_node->gst_element, video_filter, FALSE); - GstCaps *video_caps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_VIDEO_RTP_FORMAT); + + video_caps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_VIDEO_RTP_FORMAT); g_object_set(G_OBJECT(video_filter), "caps", video_caps, NULL); gst_caps_unref(video_caps); + gst_element_link_pads(video_filter, "src", rtpbin, "send_rtp_sink_0"); - GstGhostPad *ghost_pad = (GstGhostPad *)gst_element_get_static_pad(ms_node->gst_element, MS_RTP_PAD_VIDEO_IN); + ghost_pad = (GstGhostPad *)gst_element_get_static_pad(ms_node->gst_element, MS_RTP_PAD_VIDEO_IN); if (ghost_pad) { if (gst_ghost_pad_set_target(ghost_pad, gst_element_get_static_pad(video_filter, "sink"))) ms_info(" Capsfilter for [%s] in RTP is set and linked", MS_RTP_PAD_VIDEO_IN); @@ -1534,23 +1807,24 @@ gboolean __ms_rtp_element_prepare(media_streamer_node_s *ms_node) if (g_value_get_int(val) > RTP_STREAM_DISABLED) { rtp_el = __ms_element_create("udpsink", MS_RTP_PAD_AUDIO_OUT"_rtp"); __ms_bin_add_element(ms_node->gst_element, rtp_el, FALSE); + rtcp_el = __ms_element_create("udpsink", MS_RTP_PAD_AUDIO_OUT"_rctp"); __ms_bin_add_element(ms_node->gst_element, rtcp_el, FALSE); - GstElement *audio_filter = __ms_element_create("capsfilter", NULL); + audio_filter = __ms_element_create("capsfilter", NULL); __ms_bin_add_element(ms_node->gst_element, audio_filter, FALSE); - GstCaps *audio_caps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_AUDIO_RTP_FORMAT); + + audio_caps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_AUDIO_RTP_FORMAT); g_object_set(G_OBJECT(audio_filter), "caps", audio_caps, NULL); + gst_element_link_pads(audio_filter, "src", rtpbin, "send_rtp_sink_1"); - GstGhostPad *ghost_pad = (GstGhostPad *)gst_element_get_static_pad(ms_node->gst_element, MS_RTP_PAD_AUDIO_IN); + ghost_pad = (GstGhostPad *)gst_element_get_static_pad(ms_node->gst_element, MS_RTP_PAD_AUDIO_IN); if (ghost_pad) { if (gst_ghost_pad_set_target(ghost_pad, gst_element_get_static_pad(audio_filter, "sink"))) ms_info(" Capsfilter for [%s] in RTP is set and linked", MS_RTP_PAD_AUDIO_IN); } - - ret = ret && gst_element_link_pads(rtpbin, "send_rtp_src_1", rtp_el, "sink"); ret = ret && gst_element_link_pads(rtpbin, "send_rtcp_src_1", rtcp_el, "sink"); @@ -1563,19 +1837,24 @@ gboolean __ms_rtp_element_prepare(media_streamer_node_s *ms_node) } __ms_generate_dots(ms_node->gst_element, "rtp_prepared"); + + ms_debug_fleave(); + return ret; } int __ms_add_node_into_bin(media_streamer_s *ms_streamer, media_streamer_node_s *ms_node) { int ret = MEDIA_STREAMER_ERROR_NONE; + GstElement *bin = NULL; + + ms_debug_fenter(); + ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Handle is NULL"); ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Handle is NULL"); ms_info("Try to add [%s] node into streamer, node type/subtype [%d/%d]", ms_node->name, ms_node->type, ms_node->subtype); - GstElement *bin = NULL; - switch (ms_node->type) { case MEDIA_STREAMER_NODE_TYPE_SRC: bin = ms_streamer->src_bin; @@ -1594,16 +1873,21 @@ int __ms_add_node_into_bin(media_streamer_s *ms_streamer, media_streamer_node_s ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION; } + ms_debug_fleave(); + return ret; } static gboolean __ms_parse_gst_error(media_streamer_s *ms_streamer, GstMessage *message, GError *error) { + media_streamer_error_e ret_error = MEDIA_STREAMER_ERROR_NONE; + + ms_debug_fenter(); + ms_retvm_if(!ms_streamer, FALSE, "Error: invalid Media Streamer handle."); ms_retvm_if(!error, FALSE, "Error: invalid error handle."); ms_retvm_if(!message, FALSE, "Error: invalid bus message handle."); - media_streamer_error_e ret_error = MEDIA_STREAMER_ERROR_NONE; if (error->domain == GST_CORE_ERROR) ret_error = MEDIA_STREAMER_ERROR_INVALID_OPERATION; else if (error->domain == GST_LIBRARY_ERROR) @@ -1621,19 +1905,26 @@ static gboolean __ms_parse_gst_error(media_streamer_s *ms_streamer, GstMessage * error_cb((media_streamer_h) ms_streamer, ret_error, ms_streamer->error_cb.user_data); } + ms_debug_fleave(); + return TRUE; } static GstPadProbeReturn __ms_element_event_probe(GstPad * pad, GstPadProbeInfo *info, gpointer user_data) { - GstElement *parent_element = gst_pad_get_parent_element(pad); - GstEvent *event = GST_PAD_PROBE_INFO_EVENT(info); + GstElement *parent_element = NULL; + GstEvent *event = NULL; + + ms_debug_fenter(); + parent_element = gst_pad_get_parent_element(pad); if (!parent_element) { ms_error("filed to get parent_elem"); return GST_PAD_PROBE_PASS; } + event = GST_PAD_PROBE_INFO_EVENT(info); + if (GST_PAD_PROBE_INFO_TYPE(info) & GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM) { if (GST_EVENT_TYPE(event) == GST_EVENT_BUFFERSIZE) { GValue *val_ = (GValue *) g_object_get_data(G_OBJECT(parent_element), "pad_sink"); @@ -1642,23 +1933,34 @@ static GstPadProbeReturn __ms_element_event_probe(GstPad * pad, GstPadProbeInfo return GST_PAD_PROBE_OK; } } + MS_SAFE_UNREF(parent_element); + + ms_debug_fleave(); + return GST_PAD_PROBE_PASS; } gboolean __ms_element_lock_state(const GValue *item, GValue *ret, gpointer user_data) { - GstElement *sink_element = GST_ELEMENT(g_value_get_object(item)); - g_value_set_boolean(ret, FALSE); + GstElement *sink_element = NULL; + GstPad *sink_pad = NULL; + int probe_id = 0; + + ms_debug_fenter(); + + sink_element = GST_ELEMENT(g_value_get_object(item)); ms_retvm_if(!sink_element, FALSE, "Handle is NULL"); - GstPad *sink_pad = gst_element_get_static_pad(sink_element, "sink"); + g_value_set_boolean(ret, FALSE); + + sink_pad = gst_element_get_static_pad(sink_element, "sink"); if (!sink_pad) { ms_info("Failed to get static pad of element [%s]", GST_ELEMENT_NAME(sink_element)); return FALSE; } if (!gst_pad_is_blocked(sink_pad)) { - int probe_id = gst_pad_add_probe(sink_pad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM, __ms_element_event_probe, NULL, NULL); + probe_id = gst_pad_add_probe(sink_pad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM, __ms_element_event_probe, NULL, NULL); MS_SET_INT_PARAM(sink_element, "pad_sink", probe_id); ms_info("Added locking probe [%d] on pad [%s] of element [%s]", probe_id, GST_PAD_NAME(sink_pad), GST_ELEMENT_NAME(sink_element)); } else { @@ -1668,18 +1970,26 @@ gboolean __ms_element_lock_state(const GValue *item, GValue *ret, gpointer user_ g_value_set_boolean(ret, TRUE); + ms_debug_fleave(); + return TRUE; } gboolean __ms_element_unlock_state(const GValue *item, GValue *ret, gpointer user_data) { - GstElement *sink_element = GST_ELEMENT(g_value_get_object(item)); + GstElement *sink_element = NULL; + GValue *val = NULL; + GstPad *sink_pad = NULL; + + ms_debug_fenter(); + g_value_set_boolean(ret, FALSE); + sink_element = GST_ELEMENT(g_value_get_object(item)); ms_retvm_if(!sink_element, FALSE, "Handle is NULL"); - GValue *val = (GValue *) g_object_get_data(G_OBJECT(sink_element), "pad_sink"); + val = (GValue *) g_object_get_data(G_OBJECT(sink_element), "pad_sink"); if (val) { - GstPad *sink_pad = gst_element_get_static_pad(sink_element, "sink"); + sink_pad = gst_element_get_static_pad(sink_element, "sink"); if (!sink_pad) { ms_info("Failed to get static pad of element [%s]", GST_ELEMENT_NAME(sink_element)); return FALSE; @@ -1695,13 +2005,23 @@ gboolean __ms_element_unlock_state(const GValue *item, GValue *ret, gpointer use g_value_set_boolean(ret, TRUE); + ms_debug_fleave(); + return TRUE; } static gboolean __ms_bus_cb(GstBus *bus, GstMessage *message, gpointer userdata) { int ret = MEDIA_STREAMER_ERROR_NONE; - media_streamer_s *ms_streamer = (media_streamer_s *) userdata; + media_streamer_s *ms_streamer = NULL; + GError *err = NULL; + gchar *debug = NULL; + gchar *state_transition_name = NULL; + GstState state_old = 0, state_new = 0, state_pending = 0; + + ms_debug_fenter(); + + ms_streamer = (media_streamer_s *) userdata; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(ms_streamer->pipeline == NULL, MEDIA_STREAMER_ERROR_INVALID_STATE, "Pipeline doesn`t exist"); @@ -1709,8 +2029,6 @@ static gboolean __ms_bus_cb(GstBus *bus, GstMessage *message, gpointer userdata) if (message != NULL) { switch (GST_MESSAGE_TYPE(message)) { case GST_MESSAGE_ERROR:{ - GError *err = NULL; - gchar *debug = NULL; gst_message_parse_error(message, &err, &debug); /* Transform gst error code to media streamer error code. @@ -1726,9 +2044,6 @@ static gboolean __ms_bus_cb(GstBus *bus, GstMessage *message, gpointer userdata) case GST_MESSAGE_STATE_CHANGED:{ if (GST_MESSAGE_SRC(message) == GST_OBJECT(ms_streamer->pipeline)) { - GstState state_old, state_new, state_pending; - gchar *state_transition_name; - gst_message_parse_state_changed(message, &state_old, &state_new, &state_pending); state_transition_name = g_strdup_printf("Old_[%s]_New_[%s]_Pending_[%s]", gst_element_state_get_name(state_old), gst_element_state_get_name(state_new), gst_element_state_get_name(state_pending)); @@ -1793,18 +2108,25 @@ static gboolean __ms_bus_cb(GstBus *bus, GstMessage *message, gpointer userdata) break; } } + + ms_debug_fleave(); + return TRUE; } int __ms_pipeline_create(media_streamer_s *ms_streamer) { - ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - GError *err = NULL; int ret = MEDIA_STREAMER_ERROR_NONE; - - int *argc = (int *)malloc(sizeof(int)); + int *argc = NULL; char **argv = NULL; + gboolean gst_ret = 0; + + ms_debug_fenter(); + + ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); + + argc = (int *)malloc(sizeof(int)); if (!argc) { ms_error("Error allocation memory"); return MEDIA_STREAMER_ERROR_INVALID_OPERATION; @@ -1835,7 +2157,7 @@ int __ms_pipeline_create(media_streamer_s *ms_streamer) } } - gboolean gst_ret = gst_init_check(argc, &argv, &err); + gst_ret = gst_init_check(argc, &argv, &err); /* Clean memory of gstreamer arguments*/ g_strfreev(ms_streamer->ini.gst_args); ms_streamer->ini.gst_args = NULL; @@ -1869,6 +2191,8 @@ int __ms_pipeline_create(media_streamer_s *ms_streamer) gst_bin_add_many(GST_BIN(ms_streamer->pipeline), ms_streamer->src_bin, ms_streamer->sink_bin, ms_streamer->transform_bin, NULL); ms_info("Media streamer pipeline created successfully."); + ms_debug_fleave(); + return ret; } @@ -1879,6 +2203,8 @@ GstCaps *__ms_create_caps_from_fmt(media_format_h fmt) media_format_mimetype_e mime; int width, height, avg_bps, max_bps, channel, samplerate, bit; + ms_debug_fenter(); + if (!media_format_get_audio_info(fmt, &mime, &channel, &samplerate, &bit, &avg_bps)) { if (MEDIA_FORMAT_RAW == (mime & MEDIA_FORMAT_RAW)) caps = gst_caps_new_simple("audio/x-raw", "channels", G_TYPE_INT, channel, "format", @@ -1913,6 +2239,9 @@ GstCaps *__ms_create_caps_from_fmt(media_format_h fmt) ms_error("Error getting media format information"); MS_SAFE_GFREE(caps_name); + + ms_debug_fleave(); + return caps; } @@ -1920,6 +2249,14 @@ media_format_h __ms_create_fmt_from_caps(GstCaps *caps) { media_format_h fmt; GstStructure *pad_struct; + int fmt_ret = MEDIA_FORMAT_ERROR_NONE; + const gchar *pad_type = NULL; + const gchar *pad_format = NULL; + int channels = 0, bps = 0; + int width = 0, height = 0, avg_bps = 0, max_bps = 0; + + ms_debug_fenter(); + ms_retvm_if(caps == NULL, NULL, "Error: empty caps!"); if (gst_caps_is_any(caps)) { @@ -1927,23 +2264,20 @@ media_format_h __ms_create_fmt_from_caps(GstCaps *caps) return NULL; } - int fmt_ret = MEDIA_FORMAT_ERROR_NONE; - fmt_ret = media_format_create(&fmt); ms_retvm_if(fmt_ret != MEDIA_FORMAT_ERROR_NONE, NULL, "Error: while creating media format object, err[%d]!", fmt_ret); pad_struct = gst_caps_get_structure(caps, 0); - const gchar *pad_type = gst_structure_get_name(pad_struct); - const gchar *pad_format = pad_type; + pad_type = gst_structure_get_name(pad_struct); + pad_format = pad_type; /* Got raw format type if needed */ if (g_strrstr(pad_type, "/x-raw")) pad_format = gst_structure_get_string(pad_struct, "format"); ms_debug("Pad type is [%s], format: [%s]", pad_type, pad_format); - if (MS_ELEMENT_IS_VIDEO(pad_type)) { - int width, height, avg_bps, max_bps; + if (MS_ELEMENT_IS_VIDEO(pad_type)) { gst_structure_get_int(pad_struct, "width", &width); gst_structure_get_fraction(pad_struct, "framerate", &max_bps, &avg_bps); gst_structure_get_int(pad_struct, "height", &height); @@ -1954,7 +2288,6 @@ media_format_h __ms_create_fmt_from_caps(GstCaps *caps) media_format_set_video_avg_bps(fmt, avg_bps); media_format_set_video_max_bps(fmt, max_bps); } else if (MS_ELEMENT_IS_AUDIO(pad_type)) { - int channels, bps; media_format_set_audio_mime(fmt, __ms_convert_string_format_to_media_format(pad_format)); gst_structure_get_int(pad_struct, "channels", &channels); media_format_set_audio_channel(fmt, channels); @@ -1962,18 +2295,22 @@ media_format_h __ms_create_fmt_from_caps(GstCaps *caps) media_format_set_audio_avg_bps(fmt, bps); } + ms_debug_fleave(); + return fmt; } int __ms_element_pad_names(GstElement *gst_element, GstPadDirection pad_type, char ***pad_name_array, int *pads_count) { int ret = MEDIA_STREAMER_ERROR_NONE; - int pad_number = 0; GValue elem = G_VALUE_INIT; GstPad *pad = NULL; char **pad_names = NULL; GstIterator *pad_iterator = NULL; + gchar *pad_name = NULL; + + ms_debug_fenter(); if (pad_type == GST_PAD_SRC) { pad_iterator = gst_element_iterate_src_pads(gst_element); @@ -1996,7 +2333,7 @@ int __ms_element_pad_names(GstElement *gst_element, GstPadDirection pad_type, ch break; } - gchar *pad_name = gst_pad_get_name(pad); + pad_name = gst_pad_get_name(pad); pad_names[pad_number] = pad_name; g_free(pad_name); ++pad_number; @@ -2012,6 +2349,8 @@ int __ms_element_pad_names(GstElement *gst_element, GstPadDirection pad_type, ch MS_SAFE_FREE(pad_names); + ms_debug_fleave(); + return ret; } @@ -2019,19 +2358,23 @@ int __ms_element_get_pad_fmt(GstElement *gst_element, const char *pad_name, medi { GstCaps *allowed_caps = NULL; GstCaps *format_caps = NULL; + GstPad *pad = NULL; + GValue *value = NULL; + int ret = MEDIA_STREAMER_ERROR_NONE; + + ms_debug_fenter(); ms_retvm_if(gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Element handle is NULL"); - GstPad *pad = gst_element_get_static_pad(gst_element, pad_name); + pad = gst_element_get_static_pad(gst_element, pad_name); ms_retvm_if(pad == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Fail to get pad [%s] from element [%s].", pad_name, GST_ELEMENT_NAME(gst_element)); - GValue *value = (GValue *) g_object_get_data(G_OBJECT(gst_element), pad_name); + value = (GValue *) g_object_get_data(G_OBJECT(gst_element), pad_name); if (value) format_caps = GST_CAPS(gst_value_get_caps(value)); else ms_info(" No any format is set for pad [%s]", pad_name); - int ret = MEDIA_STREAMER_ERROR_NONE; allowed_caps = gst_pad_get_allowed_caps(pad); if (allowed_caps) { if (gst_caps_is_empty(allowed_caps) || gst_caps_is_any(allowed_caps)) { @@ -2053,19 +2396,28 @@ int __ms_element_get_pad_fmt(GstElement *gst_element, const char *pad_name, medi gst_caps_unref(allowed_caps); MS_SAFE_UNREF(pad); + + ms_debug_fleave(); + return ret; } int __ms_element_set_fmt(media_streamer_node_s *node, const char *pad_name, media_format_h fmt) { - ms_retvm_if(!node || !pad_name || !fmt, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); gboolean can_accept = FALSE; + GstCaps *fmt_caps = NULL; + GstElementFactory *factory = NULL; + GstPad *node_pad = NULL; + + ms_debug_fenter(); - GstCaps *fmt_caps = __ms_create_caps_from_fmt(fmt); + ms_retvm_if(!node || !pad_name || !fmt, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); + + fmt_caps = __ms_create_caps_from_fmt(fmt); ms_retvm_if(!fmt_caps, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Can't convert fmt into Caps"); - GstElementFactory *factory = gst_element_get_factory(node->gst_element); - GstPad *node_pad = gst_element_get_static_pad(node->gst_element, pad_name); + factory = gst_element_get_factory(node->gst_element); + node_pad = gst_element_get_static_pad(node->gst_element, pad_name); if (node_pad && GST_PAD_IS_SRC(node_pad)) can_accept = gst_element_factory_can_src_any_caps(factory, fmt_caps); @@ -2086,21 +2438,28 @@ int __ms_element_set_fmt(media_streamer_node_s *node, const char *pad_name, medi MS_SAFE_UNREF(node_pad); + ms_debug_fleave(); + return MEDIA_STREAMER_ERROR_NONE; } gboolean __ms_gst_seek(GstElement *element, gint64 g_time, GstSeekFlags seek_flag) { gboolean result = FALSE; + GstEvent *event = NULL; + + ms_debug_fenter(); ms_retvm_if(element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Element is NULL"); - GstEvent *event = gst_event_new_seek(1.0, GST_FORMAT_TIME, seek_flag, - GST_SEEK_TYPE_SET, g_time, - GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE); + event = gst_event_new_seek(1.0, GST_FORMAT_TIME, seek_flag, + GST_SEEK_TYPE_SET, g_time, + GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE); if (event) result = gst_element_send_event(element, event); + ms_debug_fleave(); + return result; } @@ -2110,6 +2469,8 @@ int __ms_element_push_packet(GstElement *src_element, media_packet_h packet) GstFlowReturn gst_ret = GST_FLOW_OK; guchar *buffer_data = NULL; + ms_debug_fenter(); + ms_retvm_if(src_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); if (packet == NULL) { @@ -2155,6 +2516,8 @@ int __ms_element_push_packet(GstElement *src_element, media_packet_h packet) if (gst_ret != GST_FLOW_OK) return MEDIA_STREAMER_ERROR_INVALID_OPERATION; + ms_debug_fleave(); + return MEDIA_STREAMER_ERROR_NONE; } @@ -2163,6 +2526,11 @@ int __ms_element_pull_packet(GstElement *sink_element, media_packet_h *packet) GstSample *sample = NULL; media_format_h fmt = NULL; int ret = MEDIA_STREAMER_ERROR_NONE; + guint8 *buffer_res = NULL; + GstMapInfo map = {0,}; + GstBuffer *buffer = NULL; + + ms_debug_fenter(); ms_retvm_if(sink_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(packet == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); @@ -2173,9 +2541,7 @@ int __ms_element_pull_packet(GstElement *sink_element, media_packet_h *packet) ret = __ms_element_get_pad_fmt(sink_element, "sink", &fmt); if (ret == MEDIA_STREAMER_ERROR_NONE) { - GstMapInfo map; - guint8 *buffer_res = NULL; - GstBuffer *buffer = gst_sample_get_buffer(sample); + buffer = gst_sample_get_buffer(sample); if (!buffer) { ms_error("Failed to get buffer from sample"); media_format_unref(fmt); @@ -2201,12 +2567,19 @@ int __ms_element_pull_packet(GstElement *sink_element, media_packet_h *packet) media_format_unref(fmt); gst_sample_unref(sample); + + ms_debug_fleave(); + return ret; } static void __demux_newpad_cb(GstElement * demux, GstPad * new_pad, gpointer user_data) { - media_streamer_s *ms_streamer = (media_streamer_s *) user_data; + media_streamer_s *ms_streamer = NULL; + + ms_debug_fenter(); + + ms_streamer = (media_streamer_s *) user_data; ms_retm_if(ms_streamer == NULL, "Handle is NULL"); g_mutex_lock(&ms_streamer->mutex_lock); @@ -2215,12 +2588,20 @@ static void __demux_newpad_cb(GstElement * demux, GstPad * new_pad, gpointer use ms_streamer->pads_types_list = g_list_insert_sorted(ms_streamer->pads_types_list, new_pad, __pad_type_compare); g_mutex_unlock(&ms_streamer->mutex_lock); + + ms_debug_fleave(); } static void __demux_nomore_pads_combine(GstPad *src_pad, media_streamer_s *ms_streamer) { - GstElement *found_element = gst_pad_get_parent_element(src_pad); - const gchar *new_pad_type = __ms_get_pad_type(src_pad); + GstElement *found_element = NULL; + const gchar *new_pad_type = NULL; + + ms_debug_fenter(); + + found_element = gst_pad_get_parent_element(src_pad); + new_pad_type = __ms_get_pad_type(src_pad); + if (MS_ELEMENT_IS_VIDEO(new_pad_type)) found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER); else if (MS_ELEMENT_IS_AUDIO(new_pad_type)) @@ -2232,43 +2613,62 @@ static void __demux_nomore_pads_combine(GstPad *src_pad, media_streamer_s *ms_st __ms_generate_dots(ms_streamer->pipeline, "after_demux_linked"); gst_object_unref(found_element); + + ms_debug_fleave(); } static void __demux_nomore_pads_cb(GstElement *demux, gpointer user_data) { - media_streamer_s *ms_streamer = (media_streamer_s *) user_data; + media_streamer_s *ms_streamer = NULL; + GList *iterator = NULL; + GList *list = NULL; + + ms_debug_fenter(); + + ms_streamer = (media_streamer_s *) user_data; ms_retm_if(ms_streamer == NULL, "Handle is NULL"); g_mutex_lock(&ms_streamer->mutex_lock); - GList *iterator = NULL; - GList *list = ms_streamer->pads_types_list; + list = ms_streamer->pads_types_list; for (iterator = list; iterator; iterator = iterator->next) { GstPad *src_pad = GST_PAD(iterator->data); __demux_nomore_pads_combine(src_pad, ms_streamer); } g_mutex_unlock(&ms_streamer->mutex_lock); + + ms_debug_fleave(); } int __ms_demux_element_prepare(media_streamer_s * ms_streamer, media_streamer_node_s *demux_node) { + ms_debug_fenter(); + ms_retvm_if(!ms_streamer, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(!demux_node, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); __ms_signal_create(&ms_streamer->autoplug_sig_list, demux_node->gst_element, "pad-added", G_CALLBACK(__demux_newpad_cb), ms_streamer); __ms_signal_create(&ms_streamer->autoplug_sig_list, demux_node->gst_element, "no-more-pads", G_CALLBACK(__demux_nomore_pads_cb), ms_streamer); + ms_debug_fleave(); + return MEDIA_STREAMER_ERROR_NONE; } static void __ms_typefound_cb(GstElement *typefind, guint probability, GstCaps *caps, gpointer data) { GstElement *decodebin = NULL; - media_streamer_s *ms_streamer = (media_streamer_s *) data; - media_streamer_node_s *adaptive_sink = (media_streamer_node_s *)g_hash_table_lookup(ms_streamer->nodes_table, "adaptive_sink"); - gchar *type; - GstPad *src_pad = gst_element_get_static_pad(typefind, "src"); + media_streamer_s *ms_streamer = NULL; + media_streamer_node_s *adaptive_sink = NULL; + gchar *type = NULL; + GstPad *src_pad = NULL; + + ms_debug_fenter(); + + ms_streamer = (media_streamer_s *) data; + adaptive_sink = (media_streamer_node_s *)g_hash_table_lookup(ms_streamer->nodes_table, "adaptive_sink"); + src_pad = gst_element_get_static_pad(typefind, "src"); type = gst_caps_to_string(caps); if (g_strrstr(type, "video/mpegts") && adaptive_sink) { @@ -2280,18 +2680,25 @@ static void __ms_typefound_cb(GstElement *typefind, guint probability, GstCaps * MS_SAFE_UNREF(src_pad); g_free(type); + + ms_debug_fleave(); } int __ms_find_type(media_streamer_s *ms_streamer, GstElement *src_element) { GstElement *typefind = NULL; - GstPad *src_pad = gst_element_get_static_pad(src_element, "src"); + GstPad *src_pad = NULL; + + ms_debug_fenter(); + + src_pad = gst_element_get_static_pad(src_element, "src"); typefind = gst_element_factory_make("typefind", "typefinder"); ms_retvm_if(typefind == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating element [typefind]"); __ms_bin_add_element(ms_streamer->transform_bin, typefind, TRUE); + gst_element_sync_state_with_parent(typefind); g_signal_connect(typefind, "have-type", G_CALLBACK(__ms_typefound_cb), ms_streamer); @@ -2300,5 +2707,7 @@ int __ms_find_type(media_streamer_s *ms_streamer, GstElement *src_element) MS_SAFE_UNREF(src_pad); + ms_debug_fleave(); + return MEDIA_STREAMER_ERROR_NONE; }