static GstPadProbeReturn remove_ghostpad_probe_cb (GstPad * pad, GstPadProbeInfo * info, gpointer data) { gst_pad_set_active (ghostsrc, FALSE); gst_pad_set_active (ghostsink, FALSE); gst_element_remove_pad (bin, ghostsrc); gst_element_remove_pad (bin, ghostsink); return GST_PAD_PROBE_DROP; }
static void remove_elements (RsnDvdBin * dvdbin) { gint i; GList *tmp; if (dvdbin->pieces[DVD_ELEM_MQUEUE] != NULL) { for (tmp = dvdbin->mq_req_pads; tmp; tmp = g_list_next (tmp)) { gst_element_release_request_pad (dvdbin->pieces[DVD_ELEM_MQUEUE], GST_PAD (tmp->data)); } } g_list_free (dvdbin->mq_req_pads); dvdbin->mq_req_pads = NULL; for (i = 0; i < DVD_ELEM_LAST; i++) { DVDBIN_LOCK (dvdbin); if (dvdbin->pieces[i] != NULL) { GstElement *piece = dvdbin->pieces[i]; dvdbin->pieces[i] = NULL; DVDBIN_UNLOCK (dvdbin); gst_element_set_state (piece, GST_STATE_NULL); gst_bin_remove (GST_BIN (dvdbin), piece); } else DVDBIN_UNLOCK (dvdbin); } if (dvdbin->video_pad) { if (dvdbin->video_added) gst_element_remove_pad (GST_ELEMENT (dvdbin), dvdbin->video_pad); else gst_object_unref (dvdbin->video_pad); } if (dvdbin->audio_pad) { if (dvdbin->audio_added) gst_element_remove_pad (GST_ELEMENT (dvdbin), dvdbin->audio_pad); else gst_object_unref (dvdbin->audio_pad); } if (dvdbin->subpicture_pad) { if (dvdbin->subpicture_added) gst_element_remove_pad (GST_ELEMENT (dvdbin), dvdbin->subpicture_pad); else gst_object_unref (dvdbin->subpicture_pad); } dvdbin->video_added = dvdbin->audio_added = dvdbin->subpicture_added = FALSE; dvdbin->audio_broken = FALSE; dvdbin->video_pad = dvdbin->audio_pad = dvdbin->subpicture_pad = NULL; dvdbin->did_no_more_pads = FALSE; }
static void gst_nuv_demux_destoy_src_pad (GstNuvDemux * nuv) { if (nuv->src_video_pad) { gst_element_remove_pad (GST_ELEMENT (nuv), nuv->src_video_pad); nuv->src_video_pad = NULL; } if (nuv->src_audio_pad) { gst_element_remove_pad (GST_ELEMENT (nuv), nuv->src_audio_pad); nuv->src_audio_pad = NULL; } }
void kms_element_remove_sink (KmsElement * self, GstPad * pad) { GSList *l; g_return_if_fail (self); g_return_if_fail (pad); KMS_ELEMENT_LOCK (self); l = g_slist_find_custom (self->priv->stats.probes, pad, (GCompareFunc) find_stat_probe); if (l != NULL) { KmsStatsProbe *probe = l->data; self->priv->stats.probes = g_slist_remove (self->priv->stats.probes, l->data); kms_stats_probe_destroy (probe); } KMS_ELEMENT_UNLOCK (self); // TODO: Unlink correctly pad before removing it gst_ghost_pad_set_target (GST_GHOST_PAD (pad), NULL); gst_element_remove_pad (GST_ELEMENT (self), pad); }
static void kms_element_release_pad (GstElement * element, GstPad * pad) { GstElement *agnosticbin; GstPad *target; if (g_str_has_prefix (GST_OBJECT_NAME (pad), "audio_src")) { agnosticbin = KMS_ELEMENT (element)->priv->audio_agnosticbin; } else if (g_str_has_prefix (GST_OBJECT_NAME (pad), "video_src")) { agnosticbin = KMS_ELEMENT (element)->priv->video_agnosticbin; } else { return; } // TODO: Remove pad if is a sinkpad target = gst_ghost_pad_get_target (GST_GHOST_PAD (pad)); if (target != NULL && agnosticbin != NULL) gst_element_release_request_pad (agnosticbin, target); if (GST_STATE (element) >= GST_STATE_PAUSED || GST_STATE_PENDING (element) >= GST_STATE_PAUSED) gst_pad_set_active (pad, FALSE); gst_element_remove_pad (element, pad); }
static void empathy_audio_sink_release_pad (GstElement *element, GstPad *pad) { gst_pad_set_active (pad, FALSE); gst_element_remove_pad (element, pad); }
static void switch_pads (GstHLSDemux * demux, GstCaps * newcaps) { GstPad *oldpad = demux->srcpad; GST_DEBUG ("Switching pads (oldpad:%p)", oldpad); /* First create and activate new pad */ demux->srcpad = gst_pad_new_from_static_template (&srctemplate, NULL); gst_pad_set_event_function (demux->srcpad, GST_DEBUG_FUNCPTR (gst_hls_demux_src_event)); gst_pad_set_query_function (demux->srcpad, GST_DEBUG_FUNCPTR (gst_hls_demux_src_query)); gst_pad_set_element_private (demux->srcpad, demux); gst_pad_set_active (demux->srcpad, TRUE); gst_pad_set_caps (demux->srcpad, newcaps); gst_element_add_pad (GST_ELEMENT (demux), demux->srcpad); gst_element_no_more_pads (GST_ELEMENT (demux)); if (oldpad) { /* Push out EOS */ gst_pad_push_event (oldpad, gst_event_new_eos ()); gst_pad_set_active (oldpad, FALSE); gst_element_remove_pad (GST_ELEMENT (demux), oldpad); } }
static void mpegts_parse_sync_program_pads (MpegTSParse2 * parse) { GList *walk; GST_INFO_OBJECT (parse, "begin sync pads"); for (walk = parse->pads_to_remove; walk; walk = walk->next) gst_element_remove_pad (GST_ELEMENT (parse), GST_PAD (walk->data)); for (walk = parse->pads_to_add; walk; walk = walk->next) gst_element_add_pad (GST_ELEMENT (parse), GST_PAD (walk->data)); if (parse->pads_to_add) g_list_free (parse->pads_to_add); if (parse->pads_to_remove) g_list_free (parse->pads_to_remove); GST_OBJECT_LOCK (parse); parse->pads_to_remove = NULL; parse->pads_to_add = NULL; parse->need_sync_program_pads = FALSE; GST_OBJECT_UNLOCK (parse); GST_INFO_OBJECT (parse, "end sync pads"); }
static void gst_gl_mixer_bin_release_pad (GstElement * element, GstPad * pad) { GstGLMixerBin *self = GST_GL_MIXER_BIN (element); GList *l = self->priv->input_chains; gboolean released = FALSE; GST_OBJECT_LOCK (element); while (l) { struct input_chain *chain = l->data; if (GST_PAD (chain->ghost_pad) == pad) { self->priv->input_chains = g_list_delete_link (self->priv->input_chains, l); GST_OBJECT_UNLOCK (element); _free_input_chain (chain); gst_element_remove_pad (element, pad); released = TRUE; break; } l = l->next; } if (!released) GST_OBJECT_UNLOCK (element); }
/* Unlinks and removes the pad that was created in gst_face_overlay_init () * and adds the internal element ghost pad instead */ static gboolean gst_face_overlay_create_pad (GstFaceOverlay * filter, GstPad * filter_pad, const char *pad_name, GstElement * child_element) { GstPad *peer = NULL; GstPad *pad = NULL; gboolean ok = TRUE; /* get the outside world pad connected to faceoverlay src/sink pad */ peer = gst_pad_get_peer (filter_pad); /* unlink and remove the faceoverlay src/sink pad */ toggle_pads_link_state (peer, filter_pad); gst_element_remove_pad (GST_ELEMENT (filter), filter_pad); /* add a ghost pad pointing to the child element pad (facedetect sink or * svg_overlay src depending on filter_pad direction) and add it to * faceoverlay bin */ pad = gst_element_get_static_pad (child_element, pad_name); filter_pad = gst_ghost_pad_new (pad_name, pad); gst_object_unref (GST_OBJECT (pad)); gst_element_add_pad (GST_ELEMENT (filter), filter_pad); /* link the child element pad to the outside world thru the ghost pad */ toggle_pads_link_state (peer, filter_pad); g_object_unref (peer); return ok; }
static void kms_audio_mixer_remove_sometimes_src_pad (KmsAudioMixer * self, GstElement * adder) { GstProxyPad *internal; GstPad *srcpad, *peer; srcpad = gst_element_get_static_pad (adder, "src"); peer = gst_pad_get_peer (srcpad); if (peer == NULL) goto end_phase_1; internal = gst_proxy_pad_get_internal ((GstProxyPad *) peer); if (internal == NULL) goto end_phase_2; gst_ghost_pad_set_target (GST_GHOST_PAD (internal), NULL); if (GST_STATE (self) < GST_STATE_PAUSED || GST_STATE_PENDING (self) < GST_STATE_PAUSED || GST_STATE_TARGET (self) < GST_STATE_PAUSED) { gst_pad_set_active (GST_PAD (internal), FALSE); } GST_DEBUG ("Removing source pad %" GST_PTR_FORMAT, internal); gst_element_remove_pad (GST_ELEMENT (self), GST_PAD (internal)); gst_object_unref (internal); end_phase_2: gst_object_unref (peer); end_phase_1: gst_object_unref (srcpad); }
static void gst_sdp_demux_stream_free (GstSDPDemux * demux, GstSDPStream * stream) { gint i; GST_DEBUG_OBJECT (demux, "free stream %p", stream); if (stream->caps) gst_caps_unref (stream->caps); for (i = 0; i < 2; i++) { GstElement *udpsrc = stream->udpsrc[i]; if (udpsrc) { gst_element_set_state (udpsrc, GST_STATE_NULL); gst_bin_remove (GST_BIN_CAST (demux), udpsrc); stream->udpsrc[i] = NULL; } } if (stream->udpsink) { gst_element_set_state (stream->udpsink, GST_STATE_NULL); gst_bin_remove (GST_BIN_CAST (demux), stream->udpsink); stream->udpsink = NULL; } if (stream->srcpad) { gst_pad_set_active (stream->srcpad, FALSE); if (stream->added) { gst_element_remove_pad (GST_ELEMENT_CAST (demux), stream->srcpad); stream->added = FALSE; } stream->srcpad = NULL; } g_free (stream); }
static void gst_ss_demux_stream_free (GstSSDemux * demux, GstSSDemuxStream * stream) { if (stream->queue) { while (!g_queue_is_empty(stream->queue)) { gst_buffer_unref (g_queue_pop_head (stream->queue)); } g_queue_free (stream->queue); stream->queue = NULL; } if (stream->pad) { gst_element_remove_pad (GST_ELEMENT_CAST (demux), stream->pad); stream->pad = NULL; } if (stream->cond) { g_cond_free (stream->cond); stream->cond = NULL; } if (stream->lock) { g_mutex_free (stream->lock); stream->lock = NULL; } g_free (stream); }
static void gst_stream_splitter_release_pad (GstElement * element, GstPad * pad) { GstStreamSplitter *stream_splitter = (GstStreamSplitter *) element; GList *tmp; STREAMS_LOCK (stream_splitter); tmp = g_list_find (stream_splitter->srcpads, pad); if (tmp) { GstPad *pad = (GstPad *) tmp->data; stream_splitter->srcpads = g_list_delete_link (stream_splitter->srcpads, tmp); stream_splitter->cookie++; if (pad == stream_splitter->current) { /* Deactivate current flow */ GST_DEBUG_OBJECT (element, "Removed pad was the current one"); stream_splitter->current = NULL; } gst_element_remove_pad (element, pad); } STREAMS_UNLOCK (stream_splitter); return; }
static void gst_funnel_release_pad (GstElement * element, GstPad * pad) { GstFunnel *funnel = GST_FUNNEL (element); GstFunnelPad *fpad = GST_FUNNEL_PAD_CAST (pad); gboolean got_eos; gboolean send_eos = FALSE; GST_DEBUG_OBJECT (funnel, "releasing pad %s:%s", GST_DEBUG_PAD_NAME (pad)); gst_pad_set_active (pad, FALSE); got_eos = fpad->got_eos; gst_element_remove_pad (GST_ELEMENT_CAST (funnel), pad); GST_OBJECT_LOCK (funnel); if (!got_eos && gst_funnel_all_sinkpads_eos_unlocked (funnel, NULL)) { GST_DEBUG_OBJECT (funnel, "Pad removed. All others are EOS. Sending EOS"); send_eos = TRUE; } GST_OBJECT_UNLOCK (funnel); if (send_eos) if (!gst_pad_push_event (funnel->srcpad, gst_event_new_eos ())) GST_WARNING_OBJECT (funnel, "Failure pushing EOS"); }
/* Must be called with lock! */ static void gst_stream_synchronizer_release_stream (GstStreamSynchronizer * self, GstSyncStream * stream) { GList *l; GST_DEBUG_OBJECT (self, "Releasing stream %d", stream->stream_number); for (l = self->streams; l; l = l->next) { if (l->data == stream) { self->streams = g_list_delete_link (self->streams, l); break; } } g_assert (l != NULL); if (self->streams == NULL) { self->have_group_id = TRUE; self->group_id = G_MAXUINT; } /* we can drop the lock, since stream exists now only local. * Moreover, we should drop, to prevent deadlock with STREAM_LOCK * (due to reverse lock order) when deactivating pads */ GST_STREAM_SYNCHRONIZER_UNLOCK (self); gst_pad_set_element_private (stream->srcpad, NULL); gst_pad_set_element_private (stream->sinkpad, NULL); gst_pad_set_active (stream->srcpad, FALSE); gst_element_remove_pad (GST_ELEMENT_CAST (self), stream->srcpad); gst_pad_set_active (stream->sinkpad, FALSE); gst_element_remove_pad (GST_ELEMENT_CAST (self), stream->sinkpad); g_cond_clear (&stream->stream_finish_cond); g_slice_free (GstSyncStream, stream); /* NOTE: In theory we have to check here if all streams * are EOS but the one that was removed wasn't and then * send EOS downstream. But due to the way how playsink * works this is not necessary and will only cause problems * for gapless playback. playsink will only add/remove pads * when it's reconfigured, which happens when the streams * change */ /* lock for good measure, since the caller had it */ GST_STREAM_SYNCHRONIZER_LOCK (self); }
static void fs_rtp_sub_stream_dispose (GObject *object) { FsRtpSubStream *self = FS_RTP_SUB_STREAM (object); fs_rtp_sub_stream_stop (self); fs_rtp_sub_stream_stop_no_rtcp_timeout_thread (self); if (self->priv->output_ghostpad) { gst_element_remove_pad (GST_ELEMENT (self->priv->conference), self->priv->output_ghostpad); self->priv->output_ghostpad = NULL; } if (self->priv->output_valve) { gst_element_set_locked_state (self->priv->output_valve, TRUE); gst_element_set_state (self->priv->output_valve, GST_STATE_NULL); gst_bin_remove (GST_BIN (self->priv->conference), self->priv->output_valve); self->priv->output_valve = NULL; } if (self->priv->codecbin) { gst_element_set_locked_state (self->priv->codecbin, TRUE); gst_element_set_state (self->priv->codecbin, GST_STATE_NULL); gst_bin_remove (GST_BIN (self->priv->conference), self->priv->codecbin); self->priv->codecbin = NULL; } if (self->priv->capsfilter) { gst_element_set_locked_state (self->priv->capsfilter, TRUE); gst_element_set_state (self->priv->capsfilter, GST_STATE_NULL); gst_bin_remove (GST_BIN (self->priv->conference), self->priv->capsfilter); self->priv->capsfilter = NULL; } if (self->priv->input_valve) { gst_element_set_locked_state (self->priv->input_valve, TRUE); gst_element_set_state (self->priv->input_valve, GST_STATE_NULL); gst_bin_remove (GST_BIN (self->priv->conference), self->priv->input_valve); self->priv->input_valve = NULL; } if (self->priv->blocking_id) { gst_pad_remove_data_probe (self->priv->rtpbin_pad, self->priv->blocking_id); self->priv->blocking_id = 0; } if (self->priv->rtpbin_pad) { gst_object_unref (self->priv->rtpbin_pad); self->priv->rtpbin_pad = NULL; } self->priv->disposed = TRUE; G_OBJECT_CLASS (fs_rtp_sub_stream_parent_class)->dispose (object); }
static void gst_rtp_ssrc_demux_reset (GstRtpSsrcDemux * demux) { GSList *walk; for (walk = demux->srcpads; walk; walk = g_slist_next (walk)) { GstRtpSsrcDemuxPad *dpad = (GstRtpSsrcDemuxPad *) walk->data; gst_pad_set_active (dpad->rtp_pad, FALSE); gst_pad_set_active (dpad->rtcp_pad, FALSE); gst_element_remove_pad (GST_ELEMENT_CAST (demux), dpad->rtp_pad); gst_element_remove_pad (GST_ELEMENT_CAST (demux), dpad->rtcp_pad); g_free (dpad); } g_slist_free (demux->srcpads); demux->srcpads = NULL; }
static void gst_aggregator_release_pad (GstElement * element, GstPad * pad) { GstAggregator *aggregator = GST_AGGREGATOR (element); if (aggregator->collect) gst_collect_pads_remove_pad (aggregator->collect, pad); gst_element_remove_pad (element, pad); }
static void gst_switch_release_pad (GstElement * element, GstPad * pad) { GstSwitch *swit = GST_SWITCH (element); GST_SWITCH_LOCK (swit); gst_pad_set_active (pad, FALSE); gst_element_remove_pad (element, pad); GST_SWITCH_UNLOCK (swit); }
static void fs_msn_stream_dispose (GObject *object) { FsMsnStream *self = FS_MSN_STREAM (object); FsMsnConference *conference = fs_msn_stream_get_conference (self, NULL); if (!conference) return; g_mutex_lock (&self->priv->mutex); self->priv->conference = NULL; g_mutex_unlock (&self->priv->mutex); if (self->priv->src_pad) { gst_pad_set_active (self->priv->src_pad, FALSE); gst_element_remove_pad (GST_ELEMENT (conference), self->priv->src_pad); self->priv->src_pad = NULL; } if (self->priv->recv_valve) { gst_object_unref (self->priv->recv_valve); self->priv->recv_valve = NULL; } if (self->priv->codecbin) { gst_element_set_locked_state (self->priv->codecbin, TRUE); gst_element_set_state (self->priv->codecbin, GST_STATE_NULL); gst_bin_remove (GST_BIN (conference), self->priv->codecbin); self->priv->codecbin = NULL; } if (self->priv->participant) { g_object_unref (self->priv->participant); self->priv->participant = NULL; } if (self->priv->session) { g_object_unref (self->priv->session); self->priv->session = NULL; } if (self->priv->connection) { g_object_unref (self->priv->connection); self->priv->connection = NULL; } gst_object_unref (conference); gst_object_unref (conference); G_OBJECT_CLASS (fs_msn_stream_parent_class)->dispose (object); }
static void gst_sctp_base_sink_release_pad (GstElement * element, GstPad * pad) { if (GST_STATE (element) >= GST_STATE_PAUSED || GST_STATE_PENDING (element) >= GST_STATE_PAUSED) gst_pad_set_active (pad, FALSE); gst_element_remove_pad (element, pad); }
static void gst_interleave_release_pad (GstElement * element, GstPad * pad) { GstInterleave *self = GST_INTERLEAVE (element); GList *l; GstAudioChannelPosition position; g_return_if_fail (GST_IS_INTERLEAVE_PAD (pad)); /* Take lock to make sure we're not changing this when processing buffers */ GST_OBJECT_LOCK (self->collect); g_atomic_int_add (&self->channels, -1); if (gst_pad_has_current_caps (pad)) g_atomic_int_add (&self->configured_sinkpads_counter, -1); position = GST_INTERLEAVE_PAD_CAST (pad)->channel; g_value_array_remove (self->input_channel_positions, position); /* Update channel numbers */ GST_OBJECT_LOCK (self); for (l = GST_ELEMENT_CAST (self)->sinkpads; l != NULL; l = l->next) { GstInterleavePad *ipad = GST_INTERLEAVE_PAD (l->data); if (GST_INTERLEAVE_PAD_CAST (pad)->channel < ipad->channel) ipad->channel--; } GST_OBJECT_UNLOCK (self); /* Update the src caps if we already have them */ if (self->sinkcaps) { if (self->channels > 0) { GstCaps *srccaps; GstStructure *s; srccaps = gst_caps_copy (self->sinkcaps); s = gst_caps_get_structure (srccaps, 0); gst_structure_set (s, "channels", G_TYPE_INT, self->channels, NULL); gst_interleave_set_channel_positions (self, s); gst_pad_set_active (self->src, TRUE); gst_pad_set_caps (self->src, srccaps); gst_caps_unref (srccaps); } else { gst_caps_replace (&self->sinkcaps, NULL); } } GST_OBJECT_UNLOCK (self->collect); gst_collect_pads_remove_pad (self->collect, pad); gst_element_remove_pad (element, pad); }
static void gst_streamid_demux_release_srcpad (const GValue * item, GstStreamidDemux * demux) { GstPad *pad = g_value_get_object (item); if (pad != NULL) { gst_pad_set_active (pad, FALSE); gst_element_remove_pad (GST_ELEMENT_CAST (demux), pad); } }
static gboolean gst_icydemux_remove_srcpad (GstICYDemux * icydemux) { gboolean res = TRUE; if (icydemux->srcpad != NULL) { res = gst_element_remove_pad (GST_ELEMENT (icydemux), icydemux->srcpad); g_return_val_if_fail (res != FALSE, FALSE); icydemux->srcpad = NULL; } return res; };
static void gst_output_selector_release_pad (GstElement * element, GstPad * pad) { GstOutputSelector *osel; osel = GST_OUTPUT_SELECTOR (element); GST_DEBUG_OBJECT (osel, "releasing pad"); gst_pad_set_active (pad, FALSE); gst_element_remove_pad (GST_ELEMENT_CAST (osel), pad); }
static void gst_rtp_ssrc_demux_clear_ssrc (GstRtpSsrcDemux * demux, guint32 ssrc) { GstRtpSsrcDemuxPad *dpad; GST_PAD_LOCK (demux); dpad = find_demux_pad_for_ssrc (demux, ssrc); if (dpad == NULL) { GST_PAD_UNLOCK (demux); goto unknown_pad; } GST_DEBUG_OBJECT (demux, "clearing pad for SSRC %08x", ssrc); demux->srcpads = g_slist_remove (demux->srcpads, dpad); GST_PAD_UNLOCK (demux); gst_pad_set_active (dpad->rtp_pad, FALSE); gst_pad_set_active (dpad->rtcp_pad, FALSE); g_signal_emit (G_OBJECT (demux), gst_rtp_ssrc_demux_signals[SIGNAL_REMOVED_SSRC_PAD], 0, ssrc, dpad->rtp_pad); gst_element_remove_pad (GST_ELEMENT_CAST (demux), dpad->rtp_pad); gst_element_remove_pad (GST_ELEMENT_CAST (demux), dpad->rtcp_pad); g_free (dpad); return; /* ERRORS */ unknown_pad: { GST_WARNING_OBJECT (demux, "unknown SSRC %08x", ssrc); return; } }
static void gst_multipart_demux_remove_src_pads (GstMultipartDemux * demux) { while (demux->srcpads != NULL) { GstMultipartPad *mppad = demux->srcpads->data; gst_element_remove_pad (GST_ELEMENT (demux), mppad->pad); g_free (mppad->mime); g_free (mppad); demux->srcpads = g_slist_delete_link (demux->srcpads, demux->srcpads); } demux->srcpads = NULL; demux->numpads = 0; }
static void gst_cc_extractor_reset (GstCCExtractor * filter) { filter->caption_type = GST_VIDEO_CAPTION_TYPE_UNKNOWN; gst_flow_combiner_reset (filter->combiner); gst_flow_combiner_add_pad (filter->combiner, filter->srcpad); if (filter->captionpad) { gst_flow_combiner_remove_pad (filter->combiner, filter->captionpad); gst_pad_set_active (filter->captionpad, FALSE); gst_element_remove_pad ((GstElement *) filter, filter->captionpad); filter->captionpad = NULL; } }
static void kms_mixer_endpoint_valve_removed (KmsElement * self, GstElement * valve, const gchar * pad_name) { GstPad *src = gst_element_get_static_pad (GST_ELEMENT (self), pad_name); GstPad *peer = gst_pad_get_peer (src); if (peer != NULL) { gst_pad_unlink (src, peer); g_object_unref (peer); } gst_element_remove_pad (GST_ELEMENT (self), src); }