static void gst_ghost_pad_init (GstGhostPad * pad) { gst_pad_set_activatepull_function (GST_PAD_CAST (pad), GST_DEBUG_FUNCPTR (gst_ghost_pad_do_activate_pull)); gst_pad_set_activatepush_function (GST_PAD_CAST (pad), GST_DEBUG_FUNCPTR (gst_ghost_pad_do_activate_push)); }
EXPORT_C #endif gboolean gst_ghost_pad_set_target (GstGhostPad * gpad, GstPad * newtarget) { GstPad *internal; GstPad *oldtarget; gboolean result; GstPadLinkReturn lret; g_return_val_if_fail (GST_IS_GHOST_PAD (gpad), FALSE); GST_PROXY_LOCK (gpad); internal = GST_PROXY_PAD_INTERNAL (gpad); GST_DEBUG_OBJECT (gpad, "set target %s:%s", GST_DEBUG_PAD_NAME (newtarget)); /* clear old target */ if ((oldtarget = GST_PROXY_PAD_TARGET (gpad))) { /* if we have an internal pad, unlink */ if (internal) { if (GST_PAD_IS_SRC (internal)) gst_pad_unlink (internal, oldtarget); else gst_pad_unlink (oldtarget, internal); } } result = gst_proxy_pad_set_target_unlocked (GST_PAD_CAST (gpad), newtarget); if (result && newtarget) { /* and link to internal pad */ GST_DEBUG_OBJECT (gpad, "connecting internal pad to target"); if (GST_PAD_IS_SRC (internal)) lret = gst_pad_link (internal, newtarget); else lret = gst_pad_link (newtarget, internal); if (lret != GST_PAD_LINK_OK) goto link_failed; } GST_PROXY_UNLOCK (gpad); return result; /* ERRORS */ link_failed: { GST_WARNING_OBJECT (gpad, "could not link internal and target, reason:%d", lret); /* and unset target again */ gst_proxy_pad_set_target_unlocked (GST_PAD_CAST (gpad), NULL); GST_PROXY_UNLOCK (gpad); return FALSE; } }
static void gst_ghost_pad_init (GstGhostPad * pad) { GST_GHOST_PAD_PRIVATE (pad) = G_TYPE_INSTANCE_GET_PRIVATE (pad, GST_TYPE_GHOST_PAD, GstGhostPadPrivate); gst_pad_set_setcaps_function (GST_PAD_CAST (pad), GST_DEBUG_FUNCPTR (gst_ghost_pad_do_setcaps)); gst_pad_set_activatepull_function (GST_PAD_CAST (pad), GST_DEBUG_FUNCPTR (gst_ghost_pad_do_activate_pull)); gst_pad_set_activatepush_function (GST_PAD_CAST (pad), GST_DEBUG_FUNCPTR (gst_ghost_pad_do_activate_push)); }
static void splitmux_part_reader_reset (GstSplitMuxPartReader * reader) { GList *cur; SPLITMUX_PART_LOCK (reader); for (cur = g_list_first (reader->pads); cur != NULL; cur = g_list_next (cur)) { GstPad *pad = GST_PAD_CAST (cur->data); gst_pad_set_active (GST_PAD_CAST (pad), FALSE); gst_object_unref (GST_OBJECT_CAST (pad)); } g_list_free (reader->pads); reader->pads = NULL; SPLITMUX_PART_UNLOCK (reader); }
/** * gst_ghost_pad_set_target: * @gpad: the #GstGhostPad * @newtarget: (transfer none) (allow-none): the new pad target * * Set the new target of the ghostpad @gpad. Any existing target * is unlinked and links to the new target are established. if @newtarget is * %NULL the target will be cleared. * * Returns: (transfer full): %TRUE if the new target could be set. This function * can return %FALSE when the internal pads could not be linked. */ gboolean gst_ghost_pad_set_target (GstGhostPad * gpad, GstPad * newtarget) { GstPad *internal; GstPad *oldtarget; GstPadLinkReturn lret; g_return_val_if_fail (GST_IS_GHOST_PAD (gpad), FALSE); g_return_val_if_fail (GST_PAD_CAST (gpad) != newtarget, FALSE); g_return_val_if_fail (newtarget != GST_PROXY_PAD_INTERNAL (gpad), FALSE); GST_OBJECT_LOCK (gpad); internal = GST_PROXY_PAD_INTERNAL (gpad); if (newtarget) GST_DEBUG_OBJECT (gpad, "set target %s:%s", GST_DEBUG_PAD_NAME (newtarget)); else GST_DEBUG_OBJECT (gpad, "clearing target"); /* clear old target */ if ((oldtarget = gst_pad_get_peer (internal))) { GST_OBJECT_UNLOCK (gpad); /* unlink internal pad */ if (GST_PAD_IS_SRC (internal)) gst_pad_unlink (internal, oldtarget); else gst_pad_unlink (oldtarget, internal); gst_object_unref (oldtarget); } else { GST_OBJECT_UNLOCK (gpad); } if (newtarget) { /* and link to internal pad without any checks */ GST_DEBUG_OBJECT (gpad, "connecting internal pad to target %" GST_PTR_FORMAT, newtarget); if (GST_PAD_IS_SRC (internal)) lret = gst_pad_link_full (internal, newtarget, GST_PAD_LINK_CHECK_NOTHING); else lret = gst_pad_link_full (newtarget, internal, GST_PAD_LINK_CHECK_NOTHING); if (lret != GST_PAD_LINK_OK) goto link_failed; } return TRUE; /* ERRORS */ link_failed: { GST_WARNING_OBJECT (gpad, "could not link internal and target, reason:%s", gst_pad_link_get_name (lret)); return FALSE; } }
static void no_more_pads (GstElement * element, GstSplitMuxPartReader * reader) { GstClockTime duration = GST_CLOCK_TIME_NONE; GList *cur; /* Query the minimum duration of any pad in this piece and store it. * FIXME: Only consider audio and video */ SPLITMUX_PART_LOCK (reader); for (cur = g_list_first (reader->pads); cur != NULL; cur = g_list_next (cur)) { GstPad *target = GST_PAD_CAST (cur->data); if (target) { gint64 cur_duration; if (gst_pad_peer_query_duration (target, GST_FORMAT_TIME, &cur_duration)) { GST_INFO_OBJECT (reader, "file %s pad %" GST_PTR_FORMAT " duration %" GST_TIME_FORMAT, reader->path, target, GST_TIME_ARGS (cur_duration)); if (cur_duration < duration) duration = cur_duration; } } } GST_INFO_OBJECT (reader, "file %s duration %" GST_TIME_FORMAT, reader->path, GST_TIME_ARGS (duration)); reader->duration = (GstClockTime) duration; reader->no_more_pads = TRUE; check_if_pads_collected (reader); SPLITMUX_PART_UNLOCK (reader); }
static void gst_play_sink_video_convert_init (GstPlaySinkVideoConvert * self) { GstPadTemplate *templ; self->lock = g_mutex_new (); gst_segment_init (&self->segment, GST_FORMAT_UNDEFINED); templ = gst_static_pad_template_get (&sinktemplate); self->sinkpad = gst_ghost_pad_new_no_target_from_template ("sink", templ); gst_pad_set_event_function (self->sinkpad, GST_DEBUG_FUNCPTR (gst_play_sink_video_convert_sink_event)); gst_pad_set_setcaps_function (self->sinkpad, GST_DEBUG_FUNCPTR (gst_play_sink_video_convert_sink_setcaps)); gst_pad_set_getcaps_function (self->sinkpad, GST_DEBUG_FUNCPTR (gst_play_sink_video_convert_getcaps)); self->sink_proxypad = GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD (self->sinkpad))); gst_element_add_pad (GST_ELEMENT_CAST (self), self->sinkpad); gst_object_unref (templ); templ = gst_static_pad_template_get (&srctemplate); self->srcpad = gst_ghost_pad_new_no_target_from_template ("src", templ); gst_pad_set_getcaps_function (self->srcpad, GST_DEBUG_FUNCPTR (gst_play_sink_video_convert_getcaps)); gst_element_add_pad (GST_ELEMENT_CAST (self), self->srcpad); gst_object_unref (templ); gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->srcpad), self->sink_proxypad); }
static void gst_selector_pad_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstSelectorPad *spad = GST_SELECTOR_PAD_CAST (object); switch (prop_id) { case PROP_PAD_RUNNING_TIME: g_value_set_int64 (value, gst_selector_pad_get_running_time (spad)); break; case PROP_PAD_TAGS: GST_OBJECT_LOCK (object); g_value_set_boxed (value, spad->tags); GST_OBJECT_UNLOCK (object); break; case PROP_PAD_ACTIVE: { GstInputSelector *sel; sel = GST_INPUT_SELECTOR (gst_pad_get_parent (spad)); g_value_set_boolean (value, gst_input_selector_is_active_sinkpad (sel, GST_PAD_CAST (spad))); gst_object_unref (sel); break; } case PROP_PAD_ALWAYS_OK: GST_OBJECT_LOCK (object); g_value_set_boolean (value, spad->always_ok); GST_OBJECT_UNLOCK (object); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_play_sink_convert_bin_init (GstPlaySinkConvertBin * self) { GstPadTemplate *templ; g_mutex_init (&self->lock); templ = gst_static_pad_template_get (&sinktemplate); self->sinkpad = gst_ghost_pad_new_no_target_from_template ("sink", templ); gst_pad_set_event_function (self->sinkpad, GST_DEBUG_FUNCPTR (gst_play_sink_convert_bin_sink_event)); gst_pad_set_query_function (self->sinkpad, GST_DEBUG_FUNCPTR (gst_play_sink_convert_bin_query)); self->sink_proxypad = GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD (self->sinkpad))); gst_element_add_pad (GST_ELEMENT_CAST (self), self->sinkpad); gst_object_unref (templ); templ = gst_static_pad_template_get (&srctemplate); self->srcpad = gst_ghost_pad_new_no_target_from_template ("src", templ); gst_pad_set_query_function (self->srcpad, GST_DEBUG_FUNCPTR (gst_play_sink_convert_bin_query)); gst_element_add_pad (GST_ELEMENT_CAST (self), self->srcpad); gst_object_unref (templ); gst_play_sink_convert_bin_add_identity (self); }
static void gst_selector_pad_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { RsnSelectorPad *pad; pad = GST_SELECTOR_PAD (object); switch (prop_id) { case PROP_PAD_TAGS: GST_OBJECT_LOCK (object); g_value_set_boxed (value, pad->tags); GST_OBJECT_UNLOCK (object); break; case PROP_PAD_ACTIVE: { RsnStreamSelector *sel; sel = RSN_STREAM_SELECTOR (gst_pad_get_parent (pad)); g_value_set_boolean (value, rsn_stream_selector_is_active_sinkpad (sel, GST_PAD_CAST (pad))); gst_object_unref (sel); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static GstPad * gst_ghost_pad_new_full (const gchar * name, GstPadDirection dir, GstPadTemplate * templ) { GstGhostPad *ret; g_return_val_if_fail (dir != GST_PAD_UNKNOWN, NULL); /* OBJECT CREATION */ if (templ) { ret = g_object_new (GST_TYPE_GHOST_PAD, "name", name, "direction", dir, "template", templ, NULL); } else { ret = g_object_new (GST_TYPE_GHOST_PAD, "name", name, "direction", dir, NULL); } if (!gst_ghost_pad_construct (ret)) goto construct_failed; return GST_PAD_CAST (ret); construct_failed: /* already logged */ gst_object_unref (ret); return NULL; }
static gboolean gst_audiomixer_sink_event (GstAggregator * agg, GstAggregatorPad * aggpad, GstEvent * event) { GstAudioMixer *audiomixer = GST_AUDIO_MIXER (agg); gboolean res = TRUE; GST_DEBUG_OBJECT (aggpad, "Got %s event on sink pad", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CAPS: { GstCaps *caps; gst_event_parse_caps (event, &caps); res = gst_audiomixer_setcaps (audiomixer, GST_PAD_CAST (aggpad), caps); gst_event_unref (event); event = NULL; break; } default: break; } if (event != NULL) return GST_AGGREGATOR_CLASS (parent_class)->sink_event (agg, aggpad, event); return res; }
static GstPad * gst_funnel_request_new_pad (GstElement * element, GstPadTemplate * templ, const gchar * name, const GstCaps * caps) { GstPad *sinkpad; GST_DEBUG_OBJECT (element, "requesting pad"); sinkpad = GST_PAD_CAST (g_object_new (GST_TYPE_FUNNEL_PAD, "name", name, "direction", templ->direction, "template", templ, NULL)); gst_pad_set_chain_function (sinkpad, GST_DEBUG_FUNCPTR (gst_funnel_sink_chain)); gst_pad_set_chain_list_function (sinkpad, GST_DEBUG_FUNCPTR (gst_funnel_sink_chain_list)); gst_pad_set_event_function (sinkpad, GST_DEBUG_FUNCPTR (gst_funnel_sink_event)); GST_OBJECT_FLAG_SET (sinkpad, GST_PAD_FLAG_PROXY_CAPS); GST_OBJECT_FLAG_SET (sinkpad, GST_PAD_FLAG_PROXY_ALLOCATION); gst_pad_set_active (sinkpad, TRUE); gst_element_add_pad (element, sinkpad); GST_DEBUG_OBJECT (element, "requested pad %s:%s", GST_DEBUG_PAD_NAME (sinkpad)); return sinkpad; }
static GstPad * _create_pad (GstMssDemux * mssdemux, GstMssStream * manifeststream) { gchar *name = NULL; GstPad *srcpad = NULL; GstMssStreamType streamtype; GstPadTemplate *tmpl = NULL; streamtype = gst_mss_stream_get_type (manifeststream); GST_DEBUG_OBJECT (mssdemux, "Found stream of type: %s", gst_mss_stream_type_name (streamtype)); /* TODO use stream's name/bitrate/index as the pad name? */ if (streamtype == MSS_STREAM_TYPE_VIDEO) { name = g_strdup_printf ("video_%02u", mssdemux->n_videos++); tmpl = gst_static_pad_template_get (&gst_mss_demux_videosrc_template); } else if (streamtype == MSS_STREAM_TYPE_AUDIO) { name = g_strdup_printf ("audio_%02u", mssdemux->n_audios++); tmpl = gst_static_pad_template_get (&gst_mss_demux_audiosrc_template); } if (tmpl != NULL) { srcpad = GST_PAD_CAST (gst_ghost_pad_new_no_target_from_template (name, tmpl)); g_free (name); gst_object_unref (tmpl); } if (!srcpad) { GST_WARNING_OBJECT (mssdemux, "Ignoring unknown type stream"); return NULL; } return srcpad; }
static void gst_ghost_pad_init (GstGhostPad * pad) { GST_GHOST_PAD_PRIVATE (pad) = gst_ghost_pad_get_instance_private (pad); gst_pad_set_activatemode_function (GST_PAD_CAST (pad), gst_ghost_pad_activate_mode_default); }
void notifyGstTagsOnPad(GstElement* element, GstPad* pad, GstTagList* tags) { #ifdef GST_API_VERSION_1 UNUSED_PARAM(element); gst_pad_push_event(GST_PAD_CAST(pad), gst_event_new_tag(tags)); #else gst_element_found_tags_for_pad(element, pad, tags); #endif }
static gboolean forward_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data) { GstPad *srcpad = GST_PAD_CAST (user_data); gst_pad_push_event (srcpad, gst_event_ref (*event)); return TRUE; }
static void gst_ghost_pad_init (GstGhostPad * pad) { GST_GHOST_PAD_PRIVATE (pad) = G_TYPE_INSTANCE_GET_PRIVATE (pad, GST_TYPE_GHOST_PAD, GstGhostPadPrivate); gst_pad_set_activatemode_function (GST_PAD_CAST (pad), gst_ghost_pad_activate_mode_default); }
static void kms_agnostic_bin2_link_to_tee (KmsAgnosticBin2 * self, GstPad * pad, GstElement * tee, GstCaps * caps) { GstElement *queue = gst_element_factory_make ("queue", NULL); GstPad *target; GstProxyPad *proxy; gst_bin_add (GST_BIN (self), queue); gst_element_sync_state_with_parent (queue); if (!(gst_caps_is_any (caps) || gst_caps_is_empty (caps)) && kms_utils_caps_are_raw (caps)) { GstElement *convert = kms_utils_create_convert_for_caps (caps); GstElement *rate = kms_utils_create_rate_for_caps (caps); GstElement *mediator = kms_utils_create_mediator_element (caps); remove_element_on_unlinked (convert, "src", "sink"); if (rate) { remove_element_on_unlinked (rate, "src", "sink"); } remove_element_on_unlinked (mediator, "src", "sink"); if (rate) { gst_bin_add (GST_BIN (self), rate); } gst_bin_add_many (GST_BIN (self), convert, mediator, NULL); gst_element_sync_state_with_parent (mediator); gst_element_sync_state_with_parent (convert); if (rate) { gst_element_sync_state_with_parent (rate); } if (rate) { gst_element_link_many (queue, rate, mediator, NULL); } else { gst_element_link (queue, mediator); } gst_element_link_many (mediator, convert, NULL); target = gst_element_get_static_pad (convert, "src"); } else { target = gst_element_get_static_pad (queue, "src"); } gst_ghost_pad_set_target (GST_GHOST_PAD (pad), target); proxy = gst_proxy_pad_get_internal (GST_PROXY_PAD (pad)); gst_pad_set_query_function (GST_PAD_CAST (proxy), proxy_src_pad_query_function); g_object_unref (proxy); g_object_unref (target); link_element_to_tee (tee, queue); }
/** * gst_proxy_pad_save_thyself: * @pad: a ghost #GstPad to save. * @parent: the parent #xmlNodePtr to save the description in. * * Saves the ghost pad into an xml representation. * * Returns: the #xmlNodePtr representation of the pad. */ static xmlNodePtr gst_proxy_pad_save_thyself (GstObject * object, xmlNodePtr parent) { xmlNodePtr self; GstProxyPad *proxypad; GstPad *pad; GstPad *peer; g_return_val_if_fail (GST_IS_PROXY_PAD (object), NULL); self = xmlNewChild (parent, NULL, (xmlChar *) "ghostpad", NULL); xmlNewChild (self, NULL, (xmlChar *) "name", (xmlChar *) GST_OBJECT_NAME (object)); xmlNewChild (self, NULL, (xmlChar *) "parent", (xmlChar *) GST_OBJECT_NAME (GST_OBJECT_PARENT (object))); proxypad = GST_PROXY_PAD_CAST (object); pad = GST_PAD_CAST (proxypad); peer = GST_PAD_CAST (pad->peer); if (GST_IS_PAD (pad)) { if (GST_PAD_IS_SRC (pad)) xmlNewChild (self, NULL, (xmlChar *) "direction", (xmlChar *) "source"); else if (GST_PAD_IS_SINK (pad)) xmlNewChild (self, NULL, (xmlChar *) "direction", (xmlChar *) "sink"); else xmlNewChild (self, NULL, (xmlChar *) "direction", (xmlChar *) "unknown"); } else { xmlNewChild (self, NULL, (xmlChar *) "direction", (xmlChar *) "unknown"); } if (GST_IS_PAD (peer)) { gchar *content = g_strdup_printf ("%s.%s", GST_OBJECT_NAME (GST_PAD_PARENT (peer)), GST_PAD_NAME (peer)); xmlNewChild (self, NULL, (xmlChar *) "peer", (xmlChar *) content); g_free (content); } else { xmlNewChild (self, NULL, (xmlChar *) "peer", NULL); } return self; }
static gboolean forward_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data) { GstPad *srcpad = GST_PAD_CAST (user_data); /* Stream start and caps have already been pushed */ if (GST_EVENT_TYPE (*event) >= GST_EVENT_SEGMENT) gst_pad_push_event (srcpad, gst_event_ref (*event)); return TRUE; }
gboolean gst_stream_info_set_mute (GstStreamInfo * stream_info, gboolean mute) { g_return_val_if_fail (GST_IS_STREAM_INFO (stream_info), FALSE); if (stream_info->type == GST_STREAM_TYPE_ELEMENT) { g_warning ("cannot mute element stream"); return FALSE; } if (mute != stream_info->mute) { /* nothing really happens here. it looks like gstplaybasebin installs a * buffer probe hat drops buffers when muting. but the this removes it self * after first call. */ stream_info->mute = mute; #if 0 gst_pad_set_active ((GstPad *) GST_PAD_CAST (stream_info->object), !mute); #endif #if 0 { GstElement *element; element = gst_pad_get_parent_element ((GstPad *) GST_PAD_CAST (stream_info->object)); if (element) { if (mute) { g_signal_connect (element, "state-changed", G_CALLBACK (stream_info_change_state), stream_info); } else { g_signal_handlers_disconnect_by_func (element, G_CALLBACK (stream_info_change_state), stream_info); } gst_object_unref (element); } } #endif } return TRUE; }
/** * gst_ghost_pad_get_target: * @gpad: the #GstGhostPad * * Get the target pad of @gpad. Unref target pad after usage. * * Returns: (transfer full): the target #GstPad, can be NULL if the ghostpad * has no target set. Unref target pad after usage. */ GstPad * gst_ghost_pad_get_target (GstGhostPad * gpad) { GstPad *ret; g_return_val_if_fail (GST_IS_GHOST_PAD (gpad), NULL); ret = gst_proxy_pad_get_target (GST_PAD_CAST (gpad)); GST_DEBUG_OBJECT (gpad, "get target %s:%s", GST_DEBUG_PAD_NAME (ret)); return ret; }
static gboolean proxy_src_pad_query_function (GstPad * pad, GstObject * parent, GstQuery * query) { gboolean ret = gst_pad_query_default (pad, parent, query); if (!ret) { return ret; } if (GST_QUERY_TYPE (query) == GST_QUERY_ACCEPT_CAPS) { gboolean accepted; gst_query_parse_accept_caps_result (query, &accepted); if (!accepted) { GstProxyPad *gp = gst_proxy_pad_get_internal (GST_PROXY_PAD (pad)); KmsAgnosticBin2 *self = NULL; GST_ERROR_OBJECT (pad, "Caps not accepted: %" GST_PTR_FORMAT, query); if (gp) { self = KMS_AGNOSTIC_BIN2 (GST_OBJECT_PARENT (gp)); } if (self) { KMS_AGNOSTIC_BIN2_LOCK (self); remove_target_pad (GST_PAD_CAST (gp)); kms_agnostic_bin2_process_pad (self, GST_PAD_CAST (gp)); KMS_AGNOSTIC_BIN2_UNLOCK (self); } g_object_unref (gp); } } return ret; }
static gboolean forward_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data) { GstPad *srcpad = GST_PAD_CAST (user_data); GstFlowReturn ret; ret = gst_pad_store_sticky_event (srcpad, *event); if (ret != GST_FLOW_OK) { GST_DEBUG_OBJECT (srcpad, "storing sticky event %p (%s) failed: %s", *event, GST_EVENT_TYPE_NAME (*event), gst_flow_get_name (ret)); } return TRUE; }
static void rsn_dec_init (RsnDec * self, RsnDecClass * klass) { GstPadTemplate *templ; templ = gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass), "sink"); g_assert (templ != NULL); self->sinkpad = GST_GHOST_PAD_CAST (gst_ghost_pad_new_no_target_from_template ("sink", templ)); self->sink_event_func = GST_PAD_EVENTFUNC (self->sinkpad); gst_pad_set_event_function (GST_PAD_CAST (self->sinkpad), GST_DEBUG_FUNCPTR (rsn_dec_sink_event)); templ = gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass), "src"); g_assert (templ != NULL); self->srcpad = GST_GHOST_PAD_CAST (gst_ghost_pad_new_no_target_from_template ("src", templ)); gst_element_add_pad (GST_ELEMENT (self), GST_PAD_CAST (self->sinkpad)); gst_element_add_pad (GST_ELEMENT (self), GST_PAD_CAST (self->srcpad)); }
static GstPad * gst_tcp_mix_src_request_new_pad (GstElement * element, GstPadTemplate * templ, const gchar * unused, const GstCaps * caps) { GstTCPMixSrc *src = GST_TCP_MIX_SRC (element); GstPad *srcpad; gchar *name; gboolean res; int num; //g_print ("%s:%d: %s\n", __FILE__, __LINE__, __FUNCTION__); GST_INFO_OBJECT (src, "Requesting new pad %s.%s (caps: %s)", GST_ELEMENT_NAME (src), GST_PAD_TEMPLATE_NAME_TEMPLATE (templ), gst_caps_to_string (caps)); GST_OBJECT_LOCK (src); num = g_list_length (GST_ELEMENT_PADS (src)); name = g_strdup_printf ("src_%u", num); srcpad = GST_PAD_CAST (g_object_new (GST_TYPE_TCP_MIX_SRC_PAD, "name", name, "direction", templ->direction, "template", templ, NULL)); g_free (name); GST_OBJECT_UNLOCK (src); // see: gst_tcp_mix_src_activate_push gst_pad_set_active (srcpad, TRUE); gst_pad_activate_mode (srcpad, GST_PAD_MODE_PUSH, TRUE); gst_pad_set_activatemode_function (srcpad, (GstPadActivateModeFunction) gst_tcp_mix_src_activate_mode); gst_pad_set_query_function (srcpad, gst_tcp_mix_src_query); gst_pad_set_event_function (srcpad, gst_tcp_mix_src_event); gst_pad_set_getrange_function (srcpad, gst_tcp_mix_src_getrange); //GST_OBJECT_FLAG_SET (srcpad, GST_PAD_FLAG_PROXY_CAPS); //INFO ("add-pad: %s.%s", GST_ELEMENT_NAME (src), GST_PAD_NAME (srcpad)); res = gst_element_add_pad (GST_ELEMENT_CAST (src), srcpad); gst_tcp_mix_src_start (src, GST_TCP_MIX_SRC_PAD (srcpad)); if (G_UNLIKELY (!res)) { GST_ERROR_OBJECT (src, "Failed to add new pad"); } return srcpad; }
static gboolean rsn_dec_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { RsnDec *self = RSN_DEC (parent); gboolean ret = TRUE; const GstStructure *s = gst_event_get_structure (event); const gchar *name = (s ? gst_structure_get_name (s) : NULL); if (name && g_str_equal (name, "application/x-gst-dvd")) ret = gst_pad_push_event (GST_PAD_CAST (self->srcpad), event); else ret = self->sink_event_func (pad, parent, event); return ret; }
static GstSplitMuxPartPad * gst_splitmux_part_reader_new_proxy_pad (GstSplitMuxPartReader * reader, GstPad * target) { GstSplitMuxPartPad *pad = g_object_new (SPLITMUX_TYPE_PART_PAD, "name", GST_PAD_NAME (target), "direction", GST_PAD_SINK, NULL); pad->target = target; pad->reader = reader; gst_pad_set_active (GST_PAD_CAST (pad), TRUE); return pad; }
/* TODO(ensonic): gst_pad_get_parent_element() would not work here, should we * add this as new api, e.g. gst_pad_find_parent_element(); */ static GstElement * get_real_pad_parent (GstPad * pad) { GstObject *parent; if (!pad) return NULL; parent = GST_OBJECT_PARENT (pad); /* if parent of pad is a ghost-pad, then pad is a proxy_pad */ if (parent && GST_IS_GHOST_PAD (parent)) { pad = GST_PAD_CAST (parent); parent = GST_OBJECT_PARENT (pad); } return GST_ELEMENT_CAST (parent); }