void fs_rtp_tfrc_destroy (FsRtpTfrc *self) { GST_OBJECT_LOCK (self); if (self->modder_check_probe_id) gst_pad_remove_probe (self->in_rtp_pad, self->modder_check_probe_id); self->modder_check_probe_id = 0; if (self->in_rtp_probe_id) gst_pad_remove_probe (self->in_rtp_pad, self->in_rtp_probe_id); self->in_rtp_probe_id = 0; if (self->in_rtcp_probe_id) gst_pad_remove_probe (self->in_rtcp_pad, self->in_rtcp_probe_id); self->in_rtcp_probe_id = 0; if (self->on_ssrc_validated_id) g_signal_handler_disconnect (self->rtpsession, self->on_ssrc_validated_id); self->on_ssrc_validated_id = 0; if (self->on_sending_rtcp_id) g_signal_handler_disconnect (self->rtpsession, self->on_sending_rtcp_id); self->on_sending_rtcp_id = 0; g_hash_table_destroy (g_hash_table_ref (self->tfrc_sources)); self->fsrtpsession = NULL; GST_OBJECT_UNLOCK (self); }
static GstPadProbeReturn parsebin_pending_event_probe (GstPad * pad, GstPadProbeInfo * info, PendingPad * ppad) { GstDecodebin3 *dbin = ppad->dbin; /* We drop all events by default */ GstPadProbeReturn ret = GST_PAD_PROBE_DROP; GstEvent *ev = GST_PAD_PROBE_INFO_EVENT (info); GST_DEBUG_OBJECT (pad, "Got event %p %s", ev, GST_EVENT_TYPE_NAME (ev)); switch (GST_EVENT_TYPE (ev)) { case GST_EVENT_EOS: { GST_DEBUG_OBJECT (pad, "Pending pad marked as EOS, removing"); ppad->input->pending_pads = g_list_remove (ppad->input->pending_pads, ppad); gst_pad_remove_probe (ppad->pad, ppad->buffer_probe); gst_pad_remove_probe (ppad->pad, ppad->event_probe); g_free (ppad); check_all_streams_for_eos (dbin); } break; default: break; } return ret; }
static GstPadProbeReturn pad_probe_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) { GstElement *dummysrc; gboolean success; gchar *padname; GST_DEBUG_OBJECT (pad, "pad is blocked now"); /* remove the probe first */ gst_pad_remove_probe (pad, GST_PAD_PROBE_INFO_ID (info)); dummysrc = gst_pad_get_parent_element (pad); fail_if (dummysrc == NULL); padname = gst_pad_get_name (pad); GST_DEBUG_OBJECT (dummysrc, "Invoking action release-requested-pad for %s", padname); g_signal_emit_by_name (dummysrc, "release-requested-pad", padname, &success); fail_if (!success); g_object_unref (dummysrc); g_free (padname); return GST_PAD_PROBE_OK; }
/** * gst_buffer_straw_stop_pipeline: * @bin: the pipeline previously started via gst_buffer_straw_start_pipeline() * @pad: the pad previously passed to gst_buffer_straw_start_pipeline() * * Set @bin to #GST_STATE_NULL and release resource allocated in * gst_buffer_straw_start_pipeline(). * * You must have previously called gst_buffer_straw_start_pipeline() on * @pipeline and @pad. */ void gst_buffer_straw_stop_pipeline (GstElement * bin, GstPad * pad) { GstStateChangeReturn ret; g_mutex_lock (&lock); if (buf) gst_buffer_unref (buf); buf = NULL; gst_pad_remove_probe (pad, (guint) id); id = 0; g_cond_signal (&cond); g_mutex_unlock (&lock); ret = gst_element_set_state (bin, GST_STATE_NULL); fail_if (ret == GST_STATE_CHANGE_FAILURE, "Could not stop test pipeline"); if (ret == GST_STATE_CHANGE_ASYNC) { ret = gst_element_get_state (bin, NULL, NULL, GST_CLOCK_TIME_NONE); fail_if (ret != GST_STATE_CHANGE_SUCCESS, "Could not stop test pipeline"); } g_mutex_lock (&lock); if (buf) gst_buffer_unref (buf); buf = NULL; g_mutex_unlock (&lock); }
static GstPadProbeReturn buffer_probe_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) { gboolean call; GST_DEBUG_OBJECT (pad, "Removing probe %lu", GST_PAD_PROBE_INFO_ID (info)); G_LOCK (hash_mutex); if (!g_hash_table_contains (padhash, pad)) { GST_DEBUG ("Inserting %" GST_PTR_FORMAT, pad); g_hash_table_insert (padhash, GST_OBJECT_NAME (pad), NULL); G_UNLOCK (hash_mutex); call = g_atomic_int_dec_and_test (&counter); } else { G_UNLOCK (hash_mutex); call = FALSE; } gst_pad_remove_probe (pad, GST_PAD_PROBE_INFO_ID (info)); if (call) { g_idle_add (recv_callback, cb_data); } return GST_PAD_PROBE_OK; }
static void on_demuxElementAdded (GstBin * demux, GstElement * element, gpointer user_data) { GstAdaptiveDemuxTestEnginePrivate *priv = (GstAdaptiveDemuxTestEnginePrivate *) user_data; GstAdaptiveDemuxTestOutputStream *stream = NULL; GstPad *internal_pad; gchar *srcbin_name; gint i; srcbin_name = GST_ELEMENT_NAME (element); GST_TEST_LOCK (priv); for (i = 0; i < priv->engine.output_streams->len; i++) { stream = g_ptr_array_index (priv->engine.output_streams, i); if (strstr (srcbin_name, GST_PAD_NAME (stream->pad)) != NULL) break; } fail_unless (stream != NULL); /* keep the reference to the internal_pad. * We will need it to identify the stream in the on_demuxReceivesEvent callback */ if (stream->internal_pad) { gst_pad_remove_probe (stream->internal_pad, stream->internal_pad_probe); gst_object_unref (stream->internal_pad); } internal_pad = gst_element_get_static_pad (element, "src"); stream->internal_pad_probe = gst_pad_add_probe (internal_pad, GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM, (GstPadProbeCallback) on_demuxReceivesEvent, priv, NULL); stream->internal_pad = internal_pad; GST_TEST_UNLOCK (priv); }
/* 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 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 void brasero_transcode_stop_pipeline (BraseroTranscode *transcode) { BraseroTranscodePrivate *priv; GstPad *sinkpad; priv = BRASERO_TRANSCODE_PRIVATE (transcode); if (!priv->pipeline) return; sinkpad = gst_element_get_static_pad (priv->sink, "sink"); if (priv->probe) gst_pad_remove_probe (sinkpad, priv->probe); gst_object_unref (sinkpad); gst_element_set_state (priv->pipeline, GST_STATE_NULL); gst_object_unref (GST_OBJECT (priv->pipeline)); priv->link = NULL; priv->sink = NULL; priv->source = NULL; priv->convert = NULL; priv->pipeline = NULL; priv->set_active_state = 0; }
static void unblock_proxypad (GstPlaySinkConvertBin * self) { if (self->sink_proxypad_block_id != 0) { gst_pad_remove_probe (self->sink_proxypad, self->sink_proxypad_block_id); self->sink_proxypad_block_id = 0; } }
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 kms_stats_probe_remove (KmsStatsProbe * probe) { if (probe->probe_id != 0UL) { gst_pad_remove_probe (probe->pad, probe->probe_id); probe->probe_id = 0UL; } }
static void pad_removed_cb (GstElement * timeline, GstPad * pad, GESPipeline * self) { OutputChain *chain; GESTrack *track; GstPad *peer; GST_DEBUG_OBJECT (self, "pad removed %s:%s", GST_DEBUG_PAD_NAME (pad)); if (G_UNLIKELY (!(track = ges_timeline_get_track_for_pad (self->priv->timeline, pad)))) { GST_WARNING_OBJECT (self, "Couldn't find coresponding track !"); return; } if (G_UNLIKELY (!(chain = get_output_chain_for_track (self, track)))) { GST_DEBUG_OBJECT (self, "Pad wasn't used"); return; } /* Unlink encodebin */ if (chain->encodebinpad) { 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); } /* Unlink playsink */ if (chain->playsinkpad) { 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); } if (chain->blocked_pad) { GST_DEBUG_OBJECT (chain->blocked_pad, "unblocking pad"); gst_pad_remove_probe (chain->blocked_pad, chain->probe_id); gst_object_unref (chain->blocked_pad); chain->blocked_pad = NULL; chain->probe_id = 0; } /* Unlike/remove tee */ peer = gst_element_get_static_pad (chain->tee, "sink"); gst_pad_unlink (pad, peer); gst_object_unref (peer); gst_element_set_state (chain->tee, GST_STATE_NULL); gst_bin_remove (GST_BIN (self), chain->tee); self->priv->chains = g_list_remove (self->priv->chains, chain); g_free (chain); GST_DEBUG ("done"); }
void InbandTextTrackPrivateGStreamer::disconnect() { if (!m_pad) return; gst_pad_remove_probe(m_pad.get(), m_eventProbe); TrackPrivateBaseGStreamer::disconnect(); }
static void cleanup_with_event (void) { gst_pad_remove_probe (mysinkpad, myprobe); myprobe = 0; myreceivedevents = NULL; mypushedevents = NULL; cleanup (); }
static GstPadProbeReturn src_buffer_probe_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) { GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER (info); GstPad *otherpad = GST_PAD (user_data); if (GST_BUFFER_TIMESTAMP (buffer) == buf1.ts) gst_pad_remove_probe (otherpad, probe_id); return GST_PAD_PROBE_OK; }
void kms_utils_remb_event_manager_destroy (RembEventManager * manager) { kms_utils_remb_event_manager_destroy_user_data (manager); gst_pad_remove_probe (manager->pad, manager->probe_id); g_object_unref (manager->pad); g_hash_table_destroy (manager->remb_hash); g_mutex_clear (&manager->mutex); g_slice_free (RembEventManager, manager); }
static void parsebin_pad_removed_cb (GstElement * demux, GstPad * pad, DecodebinInput * inp) { GstDecodebin3 *dbin = inp->dbin; DecodebinInputStream *input = NULL; GList *tmp; GST_DEBUG_OBJECT (pad, "removed"); for (tmp = dbin->input_streams; tmp; tmp = tmp->next) { DecodebinInputStream *cand = (DecodebinInputStream *) tmp->data; if (cand->srcpad == pad) input = cand; } /* If there are no pending pads, this means we will definitely not need this * stream anymore */ if (input) { GST_DEBUG_OBJECT (pad, "stream %p", input); if (inp->pending_pads == NULL) { MultiQueueSlot *slot; GST_DEBUG_OBJECT (pad, "Remove input stream %p", input); SELECTION_LOCK (dbin); slot = get_slot_for_input (dbin, input); SELECTION_UNLOCK (dbin); remove_input_stream (dbin, input); SELECTION_LOCK (dbin); if (slot && g_list_find (dbin->slots, slot) && slot->is_drained) { /* if slot is still there and already drained, remove it in here */ if (slot->output) { DecodebinOutputStream *output = slot->output; GST_DEBUG_OBJECT (pad, "Multiqueue was drained, Remove output stream"); dbin->output_streams = g_list_remove (dbin->output_streams, output); free_output_stream (dbin, output); } GST_DEBUG_OBJECT (pad, "No pending pad, Remove multiqueue slot"); dbin->slots = g_list_remove (dbin->slots, slot); free_multiqueue_slot_async (dbin, slot); } SELECTION_UNLOCK (dbin); } else { input->srcpad = NULL; if (input->input_buffer_probe_id) gst_pad_remove_probe (pad, input->input_buffer_probe_id); input->input_buffer_probe_id = 0; } } }
static void element_remove_probe (GstElement * e, const gchar * pad_name, gulong id) { GstPad *pad; if (id == 0UL) { return; } pad = gst_element_get_static_pad (e, pad_name); gst_pad_remove_probe (pad, id); g_object_unref (pad); }
GstPadProbeReturn MediaPlayer::cb_event_probe_toggle_splitter(GstPad *pad, GstPadProbeInfo *info, gpointer user_data) { MediaPlayer * self = reinterpret_cast<MediaPlayer*>( user_data ); // remove the probe first gst_pad_remove_probe( pad, GST_PAD_PROBE_INFO_ID (info) ); // Is the element already in the bin? if ( self->m_gst_audio_karaokesplitter == 0 ) { Logger::debug( "GstMediaPlayer: karaokesplitter is not enabled, enabling"); self->m_gst_audio_karaokesplitter = self->createElement ("audiokaraoke", "karaoke", false ); // This might happen if the player requested it despite us returning no such capability if ( !self->m_gst_audio_karaokesplitter ) return GST_PAD_PROBE_OK; // Add splitter into the bin gst_bin_add( GST_BIN (self->m_gst_pipeline), self->m_gst_audio_karaokesplitter ); // Unlink the place for the splitter gst_element_unlink( self->m_gst_audioconverter, self->m_gst_audio_volume ); // Link it in gst_element_link_many( self->m_gst_audioconverter, self->m_gst_audio_karaokesplitter, self->m_gst_audio_volume, NULL ); // And start playing it gst_element_set_state( self->m_gst_audio_karaokesplitter, GST_STATE_PLAYING ); Logger::debug( "GstMediaPlayer: karaoke splitter enabled"); } else { Logger::debug( "GstMediaPlayer: karaokesplitter is enabled, disabling"); // Stop the splitter gst_element_set_state( self->m_gst_audio_karaokesplitter, GST_STATE_NULL ); // Remove splitter from the bin (it unlinks it too) gst_bin_remove( GST_BIN (self->m_gst_pipeline), self->m_gst_audio_karaokesplitter ); self->m_gst_audio_karaokesplitter = 0; // And link the disconnected elements again gst_element_link_many( self->m_gst_audioconverter, self->m_gst_audio_volume, NULL ); Logger::debug( "GstMediaPlayer: karaoke splitter disabled"); } return GST_PAD_PROBE_OK; }
static GstPadProbeReturn data_probe_cb (GstPad * pad, GstPadProbeInfo * info, KmsConnectData * data) { GstBuffer *buffer; GstMapInfo minfo; gchar *msg; buffer = GST_PAD_PROBE_INFO_BUFFER (info); if (!gst_buffer_map (buffer, &minfo, GST_MAP_READ)) { GST_ERROR_OBJECT (pad, "Failed to map input buffer"); return GST_FLOW_ERROR; } msg = g_strndup ((const gchar *) minfo.data, minfo.size); GST_INFO ("Buffer content: (%s)", msg); g_free (msg); gst_buffer_unmap (buffer, &minfo); gst_pad_remove_probe (pad, GST_PAD_PROBE_INFO_ID (info)); CONNECT_DATA_LOCK (data); if (!data->data_buff) { gboolean actived; data->data_buff = TRUE; CONNECT_DATA_UNLOCK (data); GST_DEBUG_OBJECT (data->sink, "Disabling reception of data stream"); g_object_get (G_OBJECT (data->sink), "data", &actived, NULL); if (actived) { /* Do not accept more data */ g_object_set (G_OBJECT (data->sink), "data", FALSE, NULL); } else { gchar *padname; gboolean success; padname = gst_pad_get_name (pad); g_signal_emit_by_name (data->sink, "release-requested-pad", padname, &success); fail_if (!success); } } else { CONNECT_DATA_UNLOCK (data); } return GST_PAD_PROBE_OK; }
void InbandTextTrackPrivateGStreamer::disconnect() { if (!m_pad) return; gst_pad_remove_probe(m_pad.get(), m_eventProbe); g_signal_handlers_disconnect_by_func(m_pad.get(), reinterpret_cast<gpointer>(textTrackPrivateEventCallback), this); if (m_tagTimerHandler) g_source_remove(m_tagTimerHandler); m_pad.clear(); }
static void teardown_input_selector_with_2_streams (void) { fail_unless (gst_element_set_state (selector, GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null"); gst_pad_remove_probe (output_pad, eos_probe); gst_pad_set_active (output_pad, FALSE); gst_check_teardown_sink_pad (selector); gst_check_teardown_element (selector); g_mutex_clear (&eos_probe_lock); g_cond_clear (&eos_probe_cond); }
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->latency_probe_id > 0) { gst_pad_remove_probe (port_data->video_mixer_pad, port_data->latency_probe_id); port_data->latency_probe_id = 0; } 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; } gst_bin_remove_many (GST_BIN (self), g_object_ref (port_data->capsfilter), g_object_ref (port_data->tee), g_object_ref (port_data->fakesink), 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->capsfilter, GST_STATE_NULL); gst_element_set_state (port_data->tee, GST_STATE_NULL); gst_element_set_state (port_data->fakesink, GST_STATE_NULL); g_object_unref (port_data->capsfilter); g_object_unref (port_data->tee); g_object_unref (port_data->fakesink); g_object_unref (port_data->tee_sink_pad); port_data->tee_sink_pad = NULL; port_data->capsfilter = NULL; port_data->tee = NULL; port_data->fakesink = NULL; return G_SOURCE_REMOVE; }
static void destroy_pad (PadInfos * infos) { gst_pad_remove_probe (infos->mixer_pad, infos->probe_id); if (G_LIKELY (infos->bin)) { gst_element_set_state (infos->bin, GST_STATE_NULL); gst_element_unlink (infos->bin, infos->self->mixer); gst_bin_remove (GST_BIN (infos->self), infos->bin); } if (infos->mixer_pad) { gst_element_release_request_pad (infos->self->mixer, infos->mixer_pad); gst_object_unref (infos->mixer_pad); } g_slice_free (PadInfos, infos); }
static void no_more_pads_cb (GstElement * timeline, GESPipeline * self) { GList *tmp; GST_DEBUG ("received no-more-pads"); for (tmp = self->priv->chains; tmp; tmp = g_list_next (tmp)) { OutputChain *chain = (OutputChain *) tmp->data; if (chain->blocked_pad) { GST_DEBUG_OBJECT (chain->blocked_pad, "unblocking pad"); gst_pad_remove_probe (chain->blocked_pad, chain->probe_id); gst_object_unref (chain->blocked_pad); chain->blocked_pad = NULL; chain->probe_id = 0; } } }
static GstPadProbeReturn event_probe_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) { GMainLoop *loop = user_data; GstElement *next; if (GST_EVENT_TYPE (GST_PAD_PROBE_INFO_DATA (info)) != GST_EVENT_EOS) return GST_PAD_PROBE_OK; gst_pad_remove_probe (pad, GST_PAD_PROBE_INFO_ID (info)); /* push current event back into the queue */ g_queue_push_tail (&effects, gst_object_ref (cur_effect)); /* take next effect from the queue */ next = g_queue_pop_head (&effects); if (next == NULL) { GST_DEBUG_OBJECT (pad, "no more effects"); g_main_loop_quit (loop); return GST_PAD_PROBE_DROP; } g_print ("Switching from '%s' to '%s'..\n", GST_OBJECT_NAME (cur_effect), GST_OBJECT_NAME (next)); gst_element_set_state (cur_effect, GST_STATE_NULL); /* remove unlinks automatically */ GST_DEBUG_OBJECT (pipeline, "removing %" GST_PTR_FORMAT, cur_effect); gst_bin_remove (GST_BIN (pipeline), cur_effect); GST_DEBUG_OBJECT (pipeline, "adding %" GST_PTR_FORMAT, next); gst_bin_add (GST_BIN (pipeline), next); GST_DEBUG_OBJECT (pipeline, "linking.."); gst_element_link_many (conv_before, next, conv_after, NULL); gst_element_set_state (next, GST_STATE_PLAYING); cur_effect = next; GST_DEBUG_OBJECT (pipeline, "done"); return GST_PAD_PROBE_DROP; }
/* Create input-selector with given number of sink pads and switch given number of input buffers to each sink pad. */ static void run_input_selector_buffer_count (gint num_input_pads, gint num_buffers_per_input) { /* set up input_pads ! selector ! output_pad */ gint i = 0, probe_id = 0; GList *input_pads = NULL, *output_pads = NULL; GstElement *sel = gst_check_setup_element ("input-selector"); GstPad *output_pad = gst_check_setup_sink_pad (sel, &sinktemplate); output_pads = g_list_append (output_pads, output_pad); gst_pad_set_active (output_pad, TRUE); for (i = 0; i < num_input_pads; i++) { input_pads = g_list_append (input_pads, setup_input_pad (sel)); } /* add probe */ probe_id = gst_pad_add_probe (output_pad, GST_PAD_PROBE_TYPE_DATA_BOTH, (GstPadProbeCallback) probe_cb, NULL, NULL); g_object_set_data (G_OBJECT (output_pad), "probe_id", GINT_TO_POINTER (probe_id)); /* run the test */ fail_unless (gst_element_set_state (sel, GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS, "could not set to playing"); push_newsegment_events (input_pads); push_switched_buffers (input_pads, sel, input_pads, num_buffers_per_input); count_output_buffers (output_pads, (num_input_pads * num_buffers_per_input)); fail_unless (gst_element_set_state (sel, GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null"); /* clean up */ gst_pad_remove_probe (output_pad, probe_id); gst_pad_set_active (output_pad, FALSE); gst_check_teardown_sink_pad (sel); GST_DEBUG ("setting selector pad to NULL"); selector_set_active_pad (sel, NULL); // unref input-selector active pad g_list_foreach (input_pads, (GFunc) cleanup_pad, sel); g_list_free (input_pads); g_list_free (output_pads); gst_check_teardown_element (sel); }
static void stop_pipeline (GstElement * element) { GstBuffer *buf; while ((buf = g_async_queue_try_pop (pending_buffers))) gst_buffer_unref (buf); gst_pad_remove_probe (mysinkpad, id); id = 0; gst_element_set_state (element, GST_STATE_NULL); while ((buf = g_async_queue_try_pop (pending_buffers))) gst_buffer_unref (buf); g_async_queue_unref (pending_buffers); pending_buffers = NULL; }
static void update_video_sink (GstFPSDisplaySink * self, GstElement * video_sink) { GstPad *sink_pad; if (self->video_sink) { /* remove pad probe */ sink_pad = gst_element_get_static_pad (self->video_sink, "sink"); gst_pad_remove_probe (sink_pad, self->data_probe_id); gst_object_unref (sink_pad); self->data_probe_id = -1; /* remove ghost pad target */ gst_ghost_pad_set_target (GST_GHOST_PAD (self->ghost_pad), NULL); /* remove old sink */ gst_bin_remove (GST_BIN (self), self->video_sink); gst_object_unref (self->video_sink); } /* create child elements */ self->video_sink = video_sink; if (self->video_sink == NULL) return; fps_display_sink_update_sink_sync (self); /* take a ref before bin takes the ownership */ gst_object_ref (self->video_sink); gst_bin_add (GST_BIN (self), self->video_sink); /* attach or pad probe */ sink_pad = gst_element_get_static_pad (self->video_sink, "sink"); self->data_probe_id = gst_pad_add_probe (sink_pad, GST_PAD_PROBE_TYPE_DATA_BOTH, on_video_sink_data_flow, (gpointer) self, NULL); gst_object_unref (sink_pad); }