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);
}
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)
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)) {
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));
}
}
MS_SAFE_UNREF(peer_pad);
+
+ ms_debug_fleave();
+
return ret;
}
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);
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);
}
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);
}
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;
}
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 */
if (!peer_element)
ms_info(" Element [%s] is not connected", GST_ELEMENT_NAME(previous_element));
+ ms_debug_fleave();
+
return peer_element;
}
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 */
} 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)) {
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;
}
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)) {
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);
MS_SAFE_UNREF(previous_element);
+ ms_debug_fleave();
+
return found_element;
}
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);
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;
}
}
}
}
+ 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;
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);
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))) {
__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 */
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;
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);
__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;
}
{
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);
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);
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")) {
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)
{"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);
__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);
/* 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;
}
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);
g_object_set(manifest_src, "location", location, NULL);
g_free(location);
+ ms_debug_fleave();
+
return manifest_src;
}
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) {
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))
}
+ ms_debug_fleave();
+
return FALSE;
}
{
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;
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]",
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);
gst_element = __ms_element_create_by_registry(plug_info, type);
}
+ ms_debug_fleave();
+
return gst_element;
}
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);
__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:
MS_SAFE_UNREF(encoder_parser);
MS_SAFE_UNREF(encoder_bin);
+ ms_debug_fleave();
+
return NULL;
}
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);
MS_SAFE_UNREF(decoder_bin);
return NULL;
}
+
last_elem = decoder_elem;
if (!is_hw_codec) {
__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:
MS_SAFE_UNREF(video_scale);
MS_SAFE_UNREF(decoder_bin);
+ ms_debug_fleave();
+
return NULL;
}
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);
__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);
MS_SAFE_UNREF(audio_encoder);
MS_SAFE_UNREF(audio_enc_bin);
+ ms_debug_fleave();
+
return NULL;
}
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);
__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);
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);
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);
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);
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);
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");
}
__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;
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)
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");
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 {
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;
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");
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.
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));
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;
}
}
- 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;
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;
}
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",
ms_error("Error getting media format information");
MS_SAFE_GFREE(caps_name);
+
+ ms_debug_fleave();
+
return 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)) {
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);
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);
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);
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;
MS_SAFE_FREE(pad_names);
+ ms_debug_fleave();
+
return ret;
}
{
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)) {
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);
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;
}
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) {
if (gst_ret != GST_FLOW_OK)
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ ms_debug_fleave();
+
return MEDIA_STREAMER_ERROR_NONE;
}
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");
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);
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);
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))
__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) {
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);
MS_SAFE_UNREF(src_pad);
+ ms_debug_fleave();
+
return MEDIA_STREAMER_ERROR_NONE;
}
projects / platform / core / api / mediastreamer.git / commitdiff