static void
_free_input_chain (struct input_chain *chain)
{
if (!chain)
return;
if (chain->ghost_pad)
gst_object_unref (chain->ghost_pad);
chain->ghost_pad = NULL;
if (chain->upload) {
gst_bin_remove (GST_BIN (chain->self), chain->upload);
gst_object_unref (chain->upload);
chain->upload = NULL;
}
if (chain->in_convert) {
gst_bin_remove (GST_BIN (chain->self), chain->in_convert);
gst_object_unref (chain->in_convert);
chain->in_convert = NULL;
}
if (chain->mixer_pad) {
gst_element_release_request_pad (chain->self->mixer, chain->mixer_pad);
gst_object_unref (chain->mixer_pad);
chain->mixer_pad = NULL;
}
g_free (chain);
}
void GStreamerGWorld::removePlatformVideoSink()
{
if (!m_dynamicPadName)
return;
// Get video sink bin and the elements to remove.
GstElement* sinkPtr = 0;
g_object_get(m_pipeline, "video-sink", &sinkPtr, NULL);
GRefPtr<GstElement> videoSink = adoptGRef(sinkPtr);
GRefPtr<GstElement> tee = adoptGRef(gst_bin_get_by_name(GST_BIN(videoSink.get()), "videoTee"));
GRefPtr<GstElement> platformVideoSink = adoptGRef(gst_bin_get_by_name(GST_BIN(videoSink.get()), "platformVideoSink"));
GRefPtr<GstElement> queue = adoptGRef(gst_bin_get_by_name(GST_BIN(videoSink.get()), "queue"));
GRefPtr<GstElement> colorspace = adoptGRef(gst_bin_get_by_name(GST_BIN(videoSink.get()), "colorspace"));
GRefPtr<GstElement> videoScale = adoptGRef(gst_bin_get_by_name(GST_BIN(videoSink.get()), "videoScale"));
GRefPtr<GstPad> srcPad = adoptGRef(gst_element_get_static_pad(tee.get(), m_dynamicPadName.get()));
GRefPtr<GstPad> sinkPad = adoptGRef(gst_element_get_static_pad(queue.get(), "sink"));
gst_pad_unlink(srcPad.get(), sinkPad.get());
gst_element_release_request_pad(tee.get(), srcPad.get());
gst_element_unlink_many(queue.get(), colorspace.get(), videoScale.get(), platformVideoSink.get(), NULL);
gst_bin_remove_many(GST_BIN(videoSink.get()), queue.get(), colorspace.get(), videoScale.get(), platformVideoSink.get(), NULL);
gst_element_set_state(platformVideoSink.get(), GST_STATE_NULL);
gst_element_set_state(videoScale.get(), GST_STATE_NULL);
gst_element_set_state(colorspace.get(), GST_STATE_NULL);
gst_element_set_state(queue.get(), GST_STATE_NULL);
m_dynamicPadName.clear();
}
void
MediaSink::unlinkUnchecked (GstPad *sink)
{
GstPad *peer;
GstPad *sinkPad;
if (sink == NULL)
sinkPad = gst_element_get_static_pad (getElement(), getPadName().c_str() );
else
sinkPad = sink;
if (sinkPad == NULL)
return;
peer = gst_pad_get_peer (sinkPad);
if (peer != NULL) {
gst_pad_unlink (peer, sinkPad);
g_object_unref (peer);
}
if (sink == NULL) {
GstElement *elem;
elem = gst_pad_get_parent_element (sinkPad);
gst_element_release_request_pad (elem, sinkPad);
g_object_unref (elem);
g_object_unref (sinkPad);
}
}
static GstPad *
gst_gl_mixer_bin_request_new_pad (GstElement * element, GstPadTemplate * templ,
const gchar * req_name, const GstCaps * caps)
{
GstGLMixerBin *self = GST_GL_MIXER_BIN (element);
GstPadTemplate *mixer_templ;
struct input_chain *chain;
GstPad *mixer_pad;
chain = g_new0 (struct input_chain, 1);
mixer_templ = _find_element_pad_template (self->mixer,
GST_PAD_TEMPLATE_DIRECTION (templ), GST_PAD_TEMPLATE_PRESENCE (templ));
g_return_val_if_fail (mixer_templ, NULL);
mixer_pad =
gst_element_request_pad (self->mixer, mixer_templ, req_name, NULL);
g_return_val_if_fail (mixer_pad, NULL);
if (!_create_input_chain (self, chain, mixer_pad)) {
gst_element_release_request_pad (self->mixer, mixer_pad);
_free_input_chain (chain);
return NULL;
}
GST_OBJECT_LOCK (element);
self->priv->input_chains = g_list_prepend (self->priv->input_chains, chain);
GST_OBJECT_UNLOCK (element);
gst_child_proxy_child_added (GST_CHILD_PROXY (self),
G_OBJECT (chain->ghost_pad), GST_OBJECT_NAME (chain->ghost_pad));
return GST_PAD (chain->ghost_pad);
}
static GstPadProbeReturn tee_idle_probe_cb(GstPad *teepad, GstPadProbeInfo *info, gpointer user_data)
{
OwrMediaSource * media_source = user_data;
GstElement *sink_bin;
GstPad *sinkpad;
GstObject *parent;
GstElement *tee;
gst_pad_remove_probe(teepad, GST_PAD_PROBE_INFO_ID(info));
sinkpad = gst_pad_get_peer(teepad);
g_assert(sinkpad);
sink_bin = GST_ELEMENT(gst_object_get_parent(GST_OBJECT(sinkpad)));
g_warn_if_fail(gst_pad_unlink(teepad, sinkpad));
parent = gst_pad_get_parent(teepad);
tee = GST_ELEMENT(parent);
gst_element_release_request_pad(tee, teepad);
gst_object_unref(parent);
gst_object_unref(sinkpad);
parent = gst_object_get_parent(GST_OBJECT(sink_bin));
g_assert(parent);
gst_bin_remove(GST_BIN(parent), sink_bin);
gst_element_set_state(sink_bin, GST_STATE_NULL);
gst_object_unref(sink_bin);
gst_object_unref(parent);
GST_DEBUG_OBJECT(media_source, "Source successfully unlinked");
return GST_PAD_PROBE_OK;
}
static GstPadProbeReturn
unlink_audiotestsrc (GstPad * pad, GstPadProbeInfo * info, gpointer user_data)
{
GstElement *audiotestsrc = GST_ELEMENT (user_data);
GstElement *audiomixer;
GstPad *sinkpad;
GST_DEBUG ("Blocked %" GST_PTR_FORMAT, pad);
sinkpad = gst_pad_get_peer (pad);
if (sinkpad == NULL) {
GST_DEBUG_OBJECT (pad, "No peer pad");
return GST_PAD_PROBE_DROP;
}
audiomixer = gst_pad_get_parent_element (sinkpad);
if (audiomixer == NULL) {
GST_DEBUG_OBJECT (pad, "No audiomixer");
return GST_PAD_PROBE_DROP;
}
if (!gst_pad_unlink (pad, sinkpad)) {
GST_ERROR ("Can not unilnk pads");
}
GST_DEBUG ("Releasing %" GST_PTR_FORMAT, sinkpad);
gst_element_release_request_pad (audiomixer, sinkpad);
gst_object_unref (sinkpad);
gst_object_unref (audiomixer);
g_idle_add ((GSourceFunc) remove_audiotestsrc, audiotestsrc);
return GST_PAD_PROBE_DROP;
}
static gboolean
get_pads_from_mq (GstSplitMuxSink * splitmux, GstPad ** sink_pad,
GstPad ** src_pad)
{
GstPad *mq_sink;
GstPad *mq_src;
/* Request a pad from multiqueue, then connect this one, then
* discover the corresponding output pad and return both */
mq_sink = gst_element_get_request_pad (splitmux->mq, "sink_%u");
if (mq_sink == NULL)
return FALSE;
mq_src = mq_sink_to_src (splitmux->mq, mq_sink);
if (mq_src == NULL)
goto fail;
*sink_pad = mq_sink;
*src_pad = mq_src;
return TRUE;
fail:
gst_element_release_request_pad (splitmux->mq, mq_sink);
return FALSE;
}
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);
}
/* remove the source from the pipeline after removing it from adder */
static void
remove_source (SourceInfo * info)
{
g_print ("remove freq %f\n", info->freq);
/* lock the state so that we can put it to NULL without the parent messing
* with our state */
gst_element_set_locked_state (info->element, TRUE);
/* first stop the source. Remember that this might block when in the PAUSED
* state. Alternatively one could send EOS to the source, install an event
* probe and schedule a state change/unlink/release from the mainthread.
* Note that changing the state of a source makes it emit an EOS, which can
* make adder go EOS. */
gst_element_set_state (info->element, GST_STATE_NULL);
/* unlink from adder */
gst_pad_unlink (info->srcpad, info->sinkpad);
gst_object_unref (info->srcpad);
/* remove from the bin */
gst_bin_remove (GST_BIN (pipeline), info->element);
/* give back the pad */
gst_element_release_request_pad (adder, info->sinkpad);
gst_object_unref (info->sinkpad);
g_free (info);
}
/* Clean up output/input pad and respective selector request pad */
static void
cleanup_pad (GstPad * pad, GstElement * element)
{
GstPad *selpad = NULL;
guint probe_id = 0;
fail_if (pad == NULL, "pad doesn't exist");
/* remove probe if necessary */
probe_id = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (pad), "probe_id"));
if (probe_id)
gst_pad_remove_probe (pad, probe_id);
/* unlink */
selpad = gst_pad_get_peer (pad);
if (GST_PAD_DIRECTION (selpad) == GST_PAD_SRC) {
gst_pad_unlink (selpad, pad);
} else {
gst_pad_unlink (pad, selpad);
}
GST_DEBUG_OBJECT (pad, "clean up %" GST_PTR_FORMAT " and %" GST_PTR_FORMAT,
selpad, pad);
/* cleanup the pad */
gst_pad_set_active (pad, FALSE);
ASSERT_OBJECT_REFCOUNT (pad, "pad", 1);
gst_object_unref (pad);
/* cleanup selector pad, reffed by this function (_get_peer) and creator */
gst_element_release_request_pad (element, selpad);
gst_object_unref (selpad);
}
static void
gst_mxf_mux_reset (GstMXFMux * mux)
{
GList *l;
GST_OBJECT_LOCK (mux);
while ((l = GST_ELEMENT_CAST (mux)->sinkpads) != NULL) {
GstPad *pad = (GstPad *) l->data;
gst_object_ref (pad);
GST_OBJECT_UNLOCK (mux);
gst_element_release_request_pad (GST_ELEMENT_CAST (mux), pad);
gst_object_unref (pad);
GST_OBJECT_LOCK (mux);
}
GST_OBJECT_UNLOCK (mux);
mux->state = GST_MXF_MUX_STATE_HEADER;
mux->n_pads = 0;
if (mux->metadata) {
g_hash_table_destroy (mux->metadata);
mux->preface = NULL;
g_list_free (mux->metadata_list);
mux->metadata_list = NULL;
}
mux->metadata = mxf_metadata_hash_table_new ();
mxf_partition_pack_reset (&mux->partition);
mxf_primer_pack_reset (&mux->primer);
memset (&mux->min_edit_rate, 0, sizeof (MXFFraction));
mux->last_gc_timestamp = 0;
mux->last_gc_position = 0;
mux->offset = 0;
}
void
kms_tree_bin_unlink_input_element_from_tee (KmsTreeBin * self)
{
GstPad *queue_sink, *peer, *tee_src;
GstElement *tee;
queue_sink = gst_element_get_static_pad (self->priv->input_element, "sink");
peer = gst_pad_get_peer (queue_sink);
if (GST_IS_PROXY_PAD (peer)) {
GstProxyPad *ghost;
ghost = gst_proxy_pad_get_internal (GST_PROXY_PAD (peer));
tee_src = gst_pad_get_peer (GST_PAD (ghost));
g_object_unref (peer);
g_object_unref (ghost);
} else {
tee_src = peer;
}
gst_pad_unlink (tee_src, queue_sink);
tee = gst_pad_get_parent_element (tee_src);
if (tee != NULL) {
gst_element_release_request_pad (tee, tee_src);
g_object_unref (tee);
}
g_object_unref (tee_src);
g_object_unref (queue_sink);
}
static gpointer
stop_source_thread (gpointer data)
{
FsRtpSpecialSource *self = FS_RTP_SPECIAL_SOURCE (data);
gst_element_set_locked_state (self->priv->src, TRUE);
gst_element_set_state (self->priv->src, GST_STATE_NULL);
FS_RTP_SPECIAL_SOURCE_LOCK (self);
if (self->priv->muxer_request_pad)
{
gst_element_release_request_pad (self->priv->rtpmuxer,
self->priv->muxer_request_pad);
gst_object_unref (self->priv->muxer_request_pad);
}
self->priv->muxer_request_pad = NULL;
gst_bin_remove (GST_BIN (self->priv->outer_bin), self->priv->src);
self->priv->src = NULL;
FS_RTP_SPECIAL_SOURCE_UNLOCK (self);
g_object_unref (self);
return NULL;
}
static void
change_input (gpointer pipeline)
{
GstBin *pipe = GST_BIN (pipeline);
GstElement *agnosticbin;
GstPad *peer, *sink;
GstElement *agnosticbin2 = gst_bin_get_by_name (pipe, "agnosticbin_2");
GstElement *enc = gst_element_factory_make ("vp8enc", NULL);
GstElement *fakesink = gst_bin_get_by_name (pipe, "fakesink");
g_signal_connect (G_OBJECT (fakesink), "handoff",
G_CALLBACK (fakesink_hand_off), loop);
gst_bin_add (pipe, enc);
gst_element_sync_state_with_parent (enc);
sink = gst_element_get_static_pad (agnosticbin2, "sink");
peer = gst_pad_get_peer (sink);
agnosticbin = gst_pad_get_parent_element (peer);
gst_pad_unlink (peer, sink);
GST_INFO ("Got peer: %" GST_PTR_FORMAT, peer);
gst_element_release_request_pad (agnosticbin, peer);
gst_element_link (enc, agnosticbin2);
gst_element_link (agnosticbin, enc);
g_object_unref (agnosticbin);
g_object_unref (agnosticbin2);
g_object_unref (sink);
g_object_unref (peer);
}
static void
kms_webrtc_data_session_bin_pad_removed (GstElement * sctpdec, GstPad * srcpad,
KmsWebRtcDataSessionBin * self)
{
GstPad *chann_srcpad, *sctpenc_sinkpad;
gboolean emit_signal = FALSE;
GstElement *channel;
guint sctp_stream_id;
gchar *name;
name = gst_pad_get_name (srcpad);
GST_DEBUG_OBJECT (self, "Pad removed %" GST_PTR_FORMAT, srcpad);
if (!sscanf (name, "src_%u", &sctp_stream_id)) {
g_free (name);
return;
}
g_free (name);
KMS_WEBRTC_DATA_SESSION_BIN_LOCK (self);
channel = (GstElement *) g_hash_table_lookup (self->priv->data_channels,
GUINT_TO_POINTER (sctp_stream_id));
g_hash_table_remove (self->priv->data_channels,
GUINT_TO_POINTER (sctp_stream_id));
g_hash_table_remove (self->priv->channels, GUINT_TO_POINTER (sctp_stream_id));
if (channel == NULL) {
GST_WARNING_OBJECT (self, "No data channel (%d) for pad %" GST_PTR_FORMAT,
sctp_stream_id, srcpad);
goto end;
}
gst_element_set_state (channel, GST_STATE_NULL);
chann_srcpad = gst_element_get_static_pad (channel, "src");
sctpenc_sinkpad = gst_pad_get_peer (chann_srcpad);
if (sctpenc_sinkpad != NULL) {
gst_pad_unlink (chann_srcpad, sctpenc_sinkpad);
gst_element_release_request_pad (self->priv->sctpenc, sctpenc_sinkpad);
g_object_unref (sctpenc_sinkpad);
}
g_object_unref (chann_srcpad);
gst_bin_remove (GST_BIN (self), channel);
emit_signal = TRUE;
end:
KMS_WEBRTC_DATA_SESSION_BIN_UNLOCK (self);
if (emit_signal) {
g_signal_emit (self, obj_signals[DATA_CHANNEL_CLOSED], 0, sctp_stream_id);
}
}
static gboolean
remove_elements_from_pipeline (KmsAlphaBlendingData * port_data)
{
KmsAlphaBlending *self = port_data->mixer;
GstElement *videoconvert, *videoscale, *videorate, *capsfilter, *queue,
*videobox;
KMS_ALPHA_BLENDING_LOCK (self);
videobox = port_data->videobox;
gst_element_unlink (videobox, self->priv->videomixer);
if (port_data->video_mixer_pad != NULL) {
gst_element_release_request_pad (self->priv->videomixer,
port_data->video_mixer_pad);
g_object_unref (port_data->video_mixer_pad);
port_data->video_mixer_pad = NULL;
}
videoconvert = g_object_ref (port_data->videoconvert);
videorate = g_object_ref (port_data->videorate);
queue = g_object_ref (port_data->queue);
videoscale = g_object_ref (port_data->videoscale);
capsfilter = g_object_ref (port_data->capsfilter);
g_object_ref (videobox);
g_object_unref (port_data->videoconvert_sink_pad);
port_data->videoconvert_sink_pad = NULL;
port_data->videoconvert = NULL;
port_data->videorate = NULL;
port_data->queue = NULL;
port_data->videoscale = NULL;
port_data->capsfilter = NULL;
port_data->videobox = NULL;
gst_bin_remove_many (GST_BIN (self), videoconvert, videoscale, capsfilter,
videorate, queue, videobox, NULL);
kms_base_hub_unlink_video_src (KMS_BASE_HUB (self), port_data->id);
KMS_ALPHA_BLENDING_UNLOCK (self);
gst_element_set_state (videoconvert, GST_STATE_NULL);
gst_element_set_state (videoscale, GST_STATE_NULL);
gst_element_set_state (videorate, GST_STATE_NULL);
gst_element_set_state (capsfilter, GST_STATE_NULL);
gst_element_set_state (queue, GST_STATE_NULL);
gst_element_set_state (videobox, GST_STATE_NULL);
g_object_unref (videoconvert);
g_object_unref (videoscale);
g_object_unref (videorate);
g_object_unref (capsfilter);
g_object_unref (queue);
g_object_unref (videobox);
return G_SOURCE_REMOVE;
}
static void
gst_splitmux_sink_release_pad (GstElement * element, GstPad * pad)
{
GstSplitMuxSink *splitmux = (GstSplitMuxSink *) element;
GstPad *mqsink, *mqsrc, *muxpad;
MqStreamCtx *ctx =
(MqStreamCtx *) (g_object_get_qdata ((GObject *) (pad), PAD_CONTEXT));
GST_SPLITMUX_LOCK (splitmux);
if (splitmux->muxer == NULL || splitmux->mq == NULL)
goto fail; /* Elements don't exist yet - nothing to release */
GST_INFO_OBJECT (pad, "releasing request pad");
mqsink = gst_ghost_pad_get_target (GST_GHOST_PAD (pad));
mqsrc = mq_sink_to_src (splitmux->mq, mqsink);
muxpad = gst_pad_get_peer (mqsrc);
/* Remove the context from our consideration */
splitmux->contexts = g_list_remove (splitmux->contexts, ctx);
if (ctx->sink_pad_block_id)
gst_pad_remove_probe (ctx->sinkpad, ctx->sink_pad_block_id);
if (ctx->src_pad_block_id)
gst_pad_remove_probe (ctx->srcpad, ctx->src_pad_block_id);
/* Can release the context now */
mq_stream_ctx_unref (ctx);
/* Release and free the mq input */
gst_element_release_request_pad (splitmux->mq, mqsink);
/* Release and free the muxer input */
gst_element_release_request_pad (splitmux->muxer, muxpad);
gst_object_unref (mqsink);
gst_object_unref (mqsrc);
gst_object_unref (muxpad);
gst_element_remove_pad (element, pad);
fail:
GST_SPLITMUX_UNLOCK (splitmux);
}
void
MediaSinkImpl::unlinkUnchecked (GstPad *sink)
{
GstPad *peer;
GstPad *sinkPad;
if (sink == NULL) {
sinkPad = gst_element_get_static_pad (getGstreamerElement(),
getPadName().c_str() );
} else {
sinkPad = sink;
}
if (sinkPad == NULL) {
return;
}
peer = gst_pad_get_peer (sinkPad);
if (peer != NULL) {
Glib::Threads::Cond cond;
Glib::Threads::Mutex cmutex;
bool blocked = FALSE;
std::function <void (GstPad *, GstPadProbeInfo *) >
blockedLambda = [&] (GstPad * pad, GstPadProbeInfo * info) {
Glib::Threads::Mutex::Lock lock (cmutex);
GST_DEBUG ("Peer pad blocked %" GST_PTR_FORMAT, pad);
if (blocked) {
return;
}
gst_pad_unlink (pad, sinkPad);
blocked = TRUE;
cond.signal();
};
gst_pad_add_probe (peer, (GstPadProbeType) (GST_PAD_PROBE_TYPE_BLOCKING),
pad_blocked_adaptor, &blockedLambda, NULL);
cmutex.lock ();
while (!blocked) {
cond.wait (cmutex);
}
cmutex.unlock ();
g_object_unref (peer);
}
if (sink == NULL) {
gst_element_release_request_pad (getGstreamerElement(), sinkPad);
g_object_unref (sinkPad);
}
}
static void
_unlink_track (GESPipeline * self, GESTrack * track)
{
OutputChain *chain;
GST_DEBUG_OBJECT (self, "Unlinking removed %" GST_PTR_FORMAT, track);
if (G_UNLIKELY (!(chain = get_output_chain_for_track (self, track)))) {
GST_DEBUG_OBJECT (self, "Track wasn't used");
return;
}
/* Unlink encodebin */
if (chain->encodebinpad) {
GstPad *peer = gst_pad_get_peer (chain->encodebinpad);
gst_pad_unlink (peer, chain->encodebinpad);
gst_object_unref (peer);
gst_element_release_request_pad (self->priv->encodebin,
chain->encodebinpad);
gst_object_unref (chain->encodebinpad);
}
/* Unlink playsink */
if (chain->playsinkpad) {
GstPad *peer = gst_pad_get_peer (chain->playsinkpad);
gst_pad_unlink (peer, chain->playsinkpad);
gst_object_unref (peer);
gst_element_release_request_pad (self->priv->playsink, chain->playsinkpad);
gst_object_unref (chain->playsinkpad);
}
gst_element_set_state (chain->tee, GST_STATE_NULL);
gst_bin_remove (GST_BIN (self), chain->tee);
if (chain->query_position_id) {
g_signal_handler_disconnect (ges_track_get_composition (track),
chain->query_position_id);
chain->query_position_id = 0;
}
self->priv->chains = g_list_remove (self->priv->chains, chain);
g_free (chain);
GST_DEBUG ("done");
}
static void
remove_on_unlinked (GstPad * pad, GstPad * peer, gpointer data)
{
GstElement *parent = gst_pad_get_parent_element (pad);
if (parent != NULL) {
gst_element_release_request_pad (parent, pad);
g_object_unref (parent);
}
}
static gboolean
remove_elements_from_pipeline (KmsCompositeMixerData * port_data)
{
KmsCompositeMixer *self = port_data->mixer;
KMS_COMPOSITE_MIXER_LOCK (self);
gst_element_unlink (port_data->capsfilter, self->priv->videomixer);
if (port_data->video_mixer_pad != NULL) {
gst_element_release_request_pad (self->priv->videomixer,
port_data->video_mixer_pad);
g_object_unref (port_data->video_mixer_pad);
port_data->video_mixer_pad = NULL;
}
g_object_unref (port_data->videoconvert_sink_pad);
gst_bin_remove_many (GST_BIN (self),
g_object_ref (port_data->input_capsfilter),
g_object_ref (port_data->videoconvert),
g_object_ref (port_data->videoscale),
g_object_ref (port_data->capsfilter), g_object_ref (port_data->videorate),
g_object_ref (port_data->queue), NULL);
kms_base_hub_unlink_video_src (KMS_BASE_HUB (self), port_data->id);
KMS_COMPOSITE_MIXER_UNLOCK (self);
gst_element_set_state (port_data->input_capsfilter, GST_STATE_NULL);
gst_element_set_state (port_data->videoconvert, GST_STATE_NULL);
gst_element_set_state (port_data->videoscale, GST_STATE_NULL);
gst_element_set_state (port_data->videorate, GST_STATE_NULL);
gst_element_set_state (port_data->capsfilter, GST_STATE_NULL);
gst_element_set_state (port_data->queue, GST_STATE_NULL);
g_object_unref (port_data->input_capsfilter);
g_object_unref (port_data->videoconvert);
g_object_unref (port_data->videoscale);
g_object_unref (port_data->videorate);
g_object_unref (port_data->capsfilter);
g_object_unref (port_data->queue);
port_data->videoconvert_sink_pad = NULL;
port_data->input_capsfilter = NULL;
port_data->videoconvert = NULL;
port_data->videoscale = NULL;
port_data->capsfilter = NULL;
port_data->videorate = NULL;
port_data->queue = NULL;
return G_SOURCE_REMOVE;
}
void GstUtils::release_request_pad(GstPad *pad, gpointer user_data) {
// checking if the pad has been requested and releasing it needed
GstPadTemplate *pad_templ = gst_pad_get_pad_template(pad);
if (nullptr != pad_templ
&& GST_PAD_TEMPLATE_PRESENCE(pad_templ) == GST_PAD_REQUEST) {
gst_element_release_request_pad((GstElement *)user_data,
pad);
gst_object_unref(pad); // release does not free
}
//gst_object_unref(pad_templ); // bug in gst 0.10 ?
gst_object_unref(pad); // for iterator
}
static void
remove_tee_pad_on_unlink (GstPad * pad, GstPad * peer, gpointer user_data)
{
GstElement *tee = gst_pad_get_parent_element (pad);
if (tee == NULL) {
return;
}
gst_element_release_request_pad (tee, pad);
g_object_unref (tee);
}
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;
}
void
shmdata_base_reader_release_request_pad (GstPad *pad, gpointer user_data)
{
//checking if the pad has been requested and releasing it needed
GstPadTemplate *pad_templ = gst_pad_get_pad_template (pad);
if (GST_PAD_TEMPLATE_PRESENCE (pad_templ) == GST_PAD_REQUEST) {
gst_element_release_request_pad ((GstElement *)user_data,
pad);
gst_object_unref(pad);
}
// gst_object_unref(pad_templ); // bug in gst 0.10 ?
gst_object_unref(pad); // for pad iterator
}
GST_END_TEST
GST_START_TEST (create_test)
{
GstElement *agnosticbin = gst_element_factory_make ("agnosticbin", NULL);
GstPad *pad;
pad = gst_element_get_request_pad (agnosticbin, "src_%u");
GST_DEBUG_OBJECT (pad, "Pad created");
gst_element_release_request_pad (agnosticbin, pad);
g_object_unref (agnosticbin);
}
static void
release_test_objects (struct TestData *td)
{
gst_pad_set_active (td->mysink, FALSE);
gst_pad_set_active (td->mysrc1, FALSE);
gst_pad_set_active (td->mysrc1, FALSE);
gst_object_unref (td->mysink);
gst_object_unref (td->mysrc1);
gst_object_unref (td->mysrc2);
fail_unless (gst_element_set_state (td->funnel, GST_STATE_NULL) ==
GST_STATE_CHANGE_SUCCESS);
gst_object_unref (td->funnelsrc);
gst_element_release_request_pad (td->funnel, td->funnelsink11);
gst_object_unref (td->funnelsink11);
gst_element_release_request_pad (td->funnel, td->funnelsink22);
gst_object_unref (td->funnelsink22);
gst_caps_unref (td->mycaps);
gst_object_unref (td->funnel);
}
static void
destroy_pad (PadInfos * infos)
{
if (G_LIKELY (infos->bin)) {
gst_element_set_state (infos->bin, GST_STATE_NULL);
gst_element_unlink (infos->bin, infos->self->adder);
gst_bin_remove (GST_BIN (infos->self), infos->bin);
}
if (infos->adder_pad) {
gst_element_release_request_pad (infos->self->adder, infos->adder_pad);
gst_object_unref (infos->adder_pad);
}
g_slice_free (PadInfos, infos);
}
static void
dvb_base_bin_reset (DvbBaseBin * dvbbasebin)
{
if (dvbbasebin->hwcam) {
cam_device_close (dvbbasebin->hwcam);
cam_device_free (dvbbasebin->hwcam);
dvbbasebin->hwcam = NULL;
}
if (dvbbasebin->ts_pad) {
gst_element_release_request_pad (GST_ELEMENT (dvbbasebin->mpegtsparse),
dvbbasebin->ts_pad);
dvbbasebin->ts_pad = NULL;
}
}
static void
remove_unlinked_pad (GstPad * pad, GstPad * peer, gpointer user_data)
{
GstElement *parent = gst_pad_get_parent_element (pad);
if (parent == NULL)
return;
GST_DEBUG_OBJECT (GST_OBJECT_PARENT (parent), "Removing pad %" GST_PTR_FORMAT,
pad);
gst_element_release_request_pad (parent, pad);
g_object_unref (parent);
}