template<> GstEvent* refGPtr<GstEvent>(GstEvent* ptr) { if (ptr) gst_event_ref(ptr); return ptr; }
static gboolean fs_rtp_special_sources_send_event (GList *current_extra_sources, GstEvent *event) { GList *item = NULL; if (!event) { GST_ERROR ("Could not make dtmf-event"); return FALSE; } for (item = g_list_first (current_extra_sources); item; item = g_list_next (item)) { FsRtpSpecialSource *source = item->data; gst_event_ref (event); if (fs_rtp_special_source_send_event (source, event)) { gst_event_unref (event); return TRUE; } } gst_event_unref (event); return FALSE; }
static gboolean push_event (MpegTSBase * base, GstEvent * event) { MpegTSParse2 *parse = (MpegTSParse2 *) base; GList *tmp; if (G_UNLIKELY (parse->first)) { /* We will send the segment when really starting */ if (G_UNLIKELY (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT)) { gst_event_unref (event); return TRUE; } prepare_src_pad (base, parse); } if (G_UNLIKELY (GST_EVENT_TYPE (event) == GST_EVENT_EOS)) drain_pending_buffers (parse, TRUE); for (tmp = parse->srcpads; tmp; tmp = tmp->next) { GstPad *pad = (GstPad *) tmp->data; if (pad) { gst_event_ref (event); gst_pad_push_event (pad, event); } } gst_pad_push_event (parse->srcpad, event); return TRUE; }
static gboolean forward_event_func (const GValue * val, GValue * ret, EventData * data) { GstPad *pad = g_value_get_object (val); GstEvent *event = data->event; GstPad *peer; gst_event_ref (event); GST_LOG_OBJECT (pad, "About to send event %s", GST_EVENT_TYPE_NAME (event)); peer = gst_pad_get_peer (pad); /* collect pad might have been set flushing, * so bypass core checking that and send directly to peer */ if (!peer || !gst_pad_send_event (peer, event)) { if (!peer) gst_event_unref (event); GST_WARNING_OBJECT (pad, "Sending event %p (%s) failed.", event, GST_EVENT_TYPE_NAME (event)); /* quick hack to unflush the pads, ideally we need a way to just unflush * this single collect pad */ if (data->flush) gst_pad_send_event (pad, gst_event_new_flush_stop (TRUE)); } else { g_value_set_boolean (ret, TRUE); GST_LOG_OBJECT (pad, "Sent event %p (%s).", event, GST_EVENT_TYPE_NAME (event)); } if (peer) gst_object_unref (peer); /* continue on other pads, even if one failed */ return TRUE; }
static GstEvent * add_ssrc_and_ref (GstEvent * event, guint32 ssrc) { /* Set the ssrc on the output caps */ switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CAPS: { GstCaps *caps; GstCaps *newcaps; GstStructure *s; gst_event_parse_caps (event, &caps); newcaps = gst_caps_copy (caps); s = gst_caps_get_structure (newcaps, 0); gst_structure_set (s, "ssrc", G_TYPE_UINT, ssrc, NULL); event = gst_event_new_caps (newcaps); gst_caps_unref (newcaps); break; } default: gst_event_ref (event); break; } return event; }
/* used for catching newsegment events while we don't have a sink, for * later forwarding it to the sink */ static gboolean gst_a2dp_sink_handle_event(GstPad *pad, GstEvent *event) { GstA2dpSink *self; GstTagList *taglist = NULL; GstObject *parent; self = GST_A2DP_SINK(GST_PAD_PARENT(pad)); parent = gst_element_get_parent(GST_ELEMENT(self->sink)); if (GST_EVENT_TYPE(event) == GST_EVENT_NEWSEGMENT && parent != GST_OBJECT_CAST(self)) { if (self->newseg_event != NULL) gst_event_unref(self->newseg_event); self->newseg_event = gst_event_ref(event); } else if (GST_EVENT_TYPE(event) == GST_EVENT_TAG && parent != GST_OBJECT_CAST(self)) { if (self->taglist == NULL) gst_event_parse_tag(event, &self->taglist); else { gst_event_parse_tag(event, &taglist); gst_tag_list_insert(self->taglist, taglist, GST_TAG_MERGE_REPLACE); } } if (parent != NULL) gst_object_unref(GST_OBJECT(parent)); return self->ghostpad_eventfunc(GST_PAD(self->ghostpad), event); }
static gboolean _src_event (GstAggregator * self, GstEvent * event) { gboolean res = TRUE; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_SEEK: { gst_event_ref (event); res = _do_seek (self, event); if (res) self->priv->seqnum = gst_event_get_seqnum (event); gst_event_unref (event); event = NULL; goto done; } case GST_EVENT_NAVIGATION: { /* navigation is rather pointless. */ res = FALSE; gst_event_unref (event); goto done; } default: { break; } } return _forward_event_to_all_sinkpads (self, event, FALSE); done: return res; }
static GstPadProbeReturn events_cb (GstPad * pad, GstPadProbeInfo * probe_info, gpointer user_data) { APP_STATE_T *state = (APP_STATE_T *) user_data; GstEvent *event = GST_PAD_PROBE_INFO_EVENT (probe_info); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CAPS: { if (state->caps) { gst_caps_unref (state->caps); state->caps = NULL; } gst_event_parse_caps (event, &state->caps); if (state->caps) gst_caps_ref (state->caps); break; } case GST_EVENT_FLUSH_START: flush_start (state); break; case GST_EVENT_FLUSH_STOP: flush_stop (state); break; case GST_EVENT_EOS: queue_object (state, GST_MINI_OBJECT_CAST (gst_event_ref (event)), FALSE); break; default: break; } return GST_PAD_PROBE_OK; }
static gboolean event_forward_func (GstPad * pad, EventData * evdata) { gboolean ret = TRUE; GstPad *peer = gst_pad_get_peer (pad); GstAggregatorPadPrivate *padpriv = GST_AGGREGATOR_PAD (pad)->priv; if (peer) { ret = gst_pad_send_event (peer, gst_event_ref (evdata->event)); GST_DEBUG_OBJECT (pad, "return of event push is %d", ret); gst_object_unref (peer); } evdata->result &= ret; if (ret == FALSE) { if (GST_EVENT_TYPE (evdata->event) == GST_EVENT_SEEK) GST_ERROR_OBJECT (pad, "Event %" GST_PTR_FORMAT " failed", evdata->event); else GST_INFO_OBJECT (pad, "Event %" GST_PTR_FORMAT " failed", evdata->event); if (evdata->flush) { padpriv->pending_flush_start = FALSE; padpriv->pending_flush_stop = FALSE; } } /* Always send to all pads */ return FALSE; }
static void test_play_twice_message_received (GstBus * bus, GstMessage * message, GstElement * bin) { gboolean res; GstStateChangeReturn state_res; GST_INFO ("bus message from \"%" GST_PTR_FORMAT "\": %" GST_PTR_FORMAT, GST_MESSAGE_SRC (message), message); switch (message->type) { case GST_MESSAGE_SEGMENT_DONE: play_count++; if (play_count == 1) { state_res = gst_element_set_state (bin, GST_STATE_READY); ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE); /* prepare playing again */ set_state_and_wait (bin, GST_STATE_PAUSED); res = gst_element_send_event (bin, gst_event_ref (play_seek_event)); fail_unless (res == TRUE, NULL); state_res = gst_element_set_state (bin, GST_STATE_PLAYING); ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE); } else { g_main_loop_quit (main_loop); } break; default: g_assert_not_reached (); break; } }
static gboolean gst_rtp_mux_src_event_real (GstRTPMux * rtp_mux, GstEvent * event) { GstIterator *iter; gboolean result = FALSE; gboolean done = FALSE; iter = gst_element_iterate_sink_pads (GST_ELEMENT (rtp_mux)); while (!done) { GValue item = { 0, }; switch (gst_iterator_next (iter, &item)) { case GST_ITERATOR_OK: gst_event_ref (event); result |= gst_pad_push_event (g_value_get_object (&item), event); g_value_reset (&item); break; case GST_ITERATOR_RESYNC: gst_iterator_resync (iter); result = FALSE; break; case GST_ITERATOR_ERROR: GST_WARNING_OBJECT (rtp_mux, "Error iterating sinkpads"); case GST_ITERATOR_DONE: done = TRUE; break; } } gst_iterator_free (iter); gst_event_unref (event); return result; }
static gboolean gst_play_sink_convert_bin_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstPlaySinkConvertBin *self = GST_PLAY_SINK_CONVERT_BIN (parent); gboolean ret; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CAPS: { GstCaps *caps; gst_event_parse_caps (event, &caps); ret = gst_play_sink_convert_bin_sink_setcaps (self, caps); break; } default: break; } ret = gst_pad_event_default (pad, parent, gst_event_ref (event)); gst_event_unref (event); return ret; }
static GstFlowReturn gst_smart_encoder_reencode_gop (GstSmartEncoder * smart_encoder) { GstFlowReturn res = GST_FLOW_OK; GList *tmp; if (smart_encoder->encoder == NULL) { if (!setup_recoder_pipeline (smart_encoder)) return GST_FLOW_ERROR; } /* Activate elements */ /* Set elements to PAUSED */ gst_element_set_state (smart_encoder->encoder, GST_STATE_PAUSED); gst_element_set_state (smart_encoder->decoder, GST_STATE_PAUSED); GST_INFO ("Pushing Flush start/stop to clean decoder/encoder"); gst_pad_push_event (smart_encoder->internal_srcpad, gst_event_new_flush_start ()); gst_pad_push_event (smart_encoder->internal_srcpad, gst_event_new_flush_stop (TRUE)); /* push newsegment */ GST_INFO ("Pushing newsegment %" GST_PTR_FORMAT, smart_encoder->newsegment); gst_pad_push_event (smart_encoder->internal_srcpad, gst_event_ref (smart_encoder->newsegment)); /* Push buffers through our pads */ GST_DEBUG ("Pushing pending buffers"); for (tmp = smart_encoder->pending_gop; tmp; tmp = tmp->next) { GstBuffer *buf = (GstBuffer *) tmp->data; res = gst_pad_push (smart_encoder->internal_srcpad, buf); if (G_UNLIKELY (res != GST_FLOW_OK)) break; } if (G_UNLIKELY (res != GST_FLOW_OK)) { GST_WARNING ("Error pushing pending buffers : %s", gst_flow_get_name (res)); /* Remove pending bfufers */ for (tmp = smart_encoder->pending_gop; tmp; tmp = tmp->next) { gst_buffer_unref ((GstBuffer *) tmp->data); } } else { GST_INFO ("Pushing out EOS to flush out decoder/encoder"); gst_pad_push_event (smart_encoder->internal_srcpad, gst_event_new_eos ()); } /* Activate elements */ /* Set elements to PAUSED */ gst_element_set_state (smart_encoder->encoder, GST_STATE_NULL); gst_element_set_state (smart_encoder->decoder, GST_STATE_NULL); g_list_free (smart_encoder->pending_gop); smart_encoder->pending_gop = NULL; return res; }
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 gboolean forward_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data) { GstValve *valve = user_data; if (!gst_pad_push_event (valve->srcpad, gst_event_ref (*event))) valve->need_repush_sticky = TRUE; return TRUE; }
static GstPadProbeReturn event_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) { GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info); GST_INFO ("got %" GST_PTR_FORMAT, event); myreceivedevents = g_list_append (myreceivedevents, gst_event_ref (event)); return GST_PAD_PROBE_OK; }
static gboolean forward_events (GstPad * pad, GstEvent ** event, gpointer user_data) { GstPad *srcpad = user_data; if (GST_EVENT_TYPE (*event) != GST_EVENT_EOS) gst_pad_push_event (srcpad, gst_event_ref (*event)); return TRUE; }
static GstPadProbeReturn event_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) { GstMiniObject *data = GST_PAD_PROBE_INFO_DATA (info); gboolean before_q = (gboolean) GPOINTER_TO_INT (user_data); GST_DEBUG ("event probe called %p", data); fail_unless (GST_IS_EVENT (data)); if (before_q) { switch (GST_EVENT_TYPE (GST_EVENT (data))) { case GST_EVENT_CUSTOM_UPSTREAM: case GST_EVENT_CUSTOM_BOTH: case GST_EVENT_CUSTOM_BOTH_OOB: if (got_event_before_q != NULL) break; gst_event_ref ((GstEvent *) data); g_get_current_time (&got_event_time); got_event_before_q = GST_EVENT (data); break; default: break; } } else { switch (GST_EVENT_TYPE (GST_EVENT (data))) { case GST_EVENT_CUSTOM_DOWNSTREAM: case GST_EVENT_CUSTOM_DOWNSTREAM_OOB: case GST_EVENT_CUSTOM_BOTH: case GST_EVENT_CUSTOM_BOTH_OOB: if (got_event_after_q != NULL) break; gst_event_ref ((GstEvent *) data); g_get_current_time (&got_event_time); got_event_after_q = GST_EVENT (data); break; default: break; } } return GST_PAD_PROBE_OK; }
static void check_filter_varargs (const gchar * name, GstEvent * event, gint num_buffers, const gchar * prop, va_list varargs) { static const struct { const int width, height; } resolutions[] = { { 384, 288}, { 385, 289}, { 385, 385}}; gint i, n, r; gint size; GstCaps *allcaps, *templ = gst_caps_from_string (VIDEO_CAPS_TEMPLATE_STRING); allcaps = gst_caps_normalize (templ); n = gst_caps_get_size (allcaps); for (i = 0; i < n; i++) { GstStructure *s = gst_caps_get_structure (allcaps, i); GstCaps *caps = gst_caps_new_empty (); gst_caps_append_structure (caps, gst_structure_copy (s)); /* try various resolutions */ for (r = 0; r < G_N_ELEMENTS (resolutions); ++r) { GstVideoInfo info; va_list args_cp; caps = gst_caps_make_writable (caps); gst_caps_set_simple (caps, "width", G_TYPE_INT, resolutions[r].width, "height", G_TYPE_INT, resolutions[r].height, "framerate", GST_TYPE_FRACTION, 25, 1, NULL); GST_DEBUG ("Testing with caps: %" GST_PTR_FORMAT, caps); gst_video_info_from_caps (&info, caps); size = GST_VIDEO_INFO_SIZE (&info); if (event) gst_event_ref (event); va_copy (args_cp, varargs); check_filter_caps (name, event, caps, size, num_buffers, prop, args_cp); va_end (args_cp); } gst_caps_unref (caps); } gst_caps_unref (allcaps); if (event) gst_event_unref (event); }
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; }
/* events sent to this element directly, mainly from the application */ static gboolean gst_decklink_src_send_event (GstElement * element, GstEvent * event) { GstDecklinkSrc *src; gboolean result = FALSE; src = GST_DECKLINK_SRC (element); GST_DEBUG_OBJECT (src, "handling event %p %" GST_PTR_FORMAT, event, event); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: g_atomic_int_set (&src->pending_eos, TRUE); GST_INFO_OBJECT (src, "EOS pending"); result = TRUE; break; break; case GST_EVENT_TAG: case GST_EVENT_CUSTOM_DOWNSTREAM: case GST_EVENT_CUSTOM_BOTH: /* Insert TAG, CUSTOM_DOWNSTREAM, CUSTOM_BOTH in the dataflow */ GST_OBJECT_LOCK (src); src->pending_events = g_list_append (src->pending_events, event); g_atomic_int_set (&src->have_events, TRUE); GST_OBJECT_UNLOCK (src); event = NULL; result = TRUE; break; case GST_EVENT_CUSTOM_DOWNSTREAM_OOB: case GST_EVENT_CUSTOM_BOTH_OOB: /* insert a random custom event into the pipeline */ GST_DEBUG_OBJECT (src, "pushing custom OOB event downstream"); result = gst_pad_push_event (src->videosrcpad, gst_event_ref (event)); result |= gst_pad_push_event (src->audiosrcpad, event); /* we gave away the ref to the event in the push */ event = NULL; break; case GST_EVENT_CUSTOM_UPSTREAM: /* drop */ case GST_EVENT_SEGMENT: /* sending random SEGMENT downstream can break sync - drop */ default: GST_LOG_OBJECT (src, "dropping %s event", GST_EVENT_TYPE_NAME (event)); break; } /* if we still have a ref to the event, unref it now */ if (event) gst_event_unref (event); return result; }
static gboolean gst_dvbsub_overlay_event_src (GstPad * pad, GstObject * parent, GstEvent * event) { GstDVBSubOverlay *render = GST_DVBSUB_OVERLAY (parent); gboolean ret = FALSE; gst_event_ref (event); ret = gst_pad_push_event (render->video_sinkpad, event); gst_pad_push_event (render->text_sinkpad, event); return ret; }
static gboolean forward_event_on_stream_changed (GstFunnel * funnel, GstPad * sinkpad, GstEvent * event) { GstFunnelPad *funnelpad = GST_FUNNEL_PAD_CAST (sinkpad); gboolean ret = TRUE; if (funnel->last_sinkpad == NULL || funnel->forward_sticky_events_mode == GST_FUNNEL_FORWARD_STICKY_EVENTS_MODE_ALWAYS) { GST_DEBUG_OBJECT (sinkpad, "Forwarding event %" GST_PTR_FORMAT, event); ret = gst_pad_push_event (funnel->srcpad, gst_event_ref (event)); } else if ((funnel->forward_sticky_events_mode == GST_FUNNEL_FORWARD_STICKY_EVENTS_MODE_ONCE) && (g_slist_find (funnelpad->events_sent, event) == NULL)) { GST_DEBUG_OBJECT (sinkpad, "Forwarding event %" GST_PTR_FORMAT, event); ret = gst_pad_push_event (funnel->srcpad, gst_event_ref (event)); funnelpad->events_sent = g_slist_prepend (funnelpad->events_sent, gst_event_ref (event)); } return ret; }
static gboolean gst_shout2send_event (GstBaseSink * sink, GstEvent * event) { GstShout2send *shout2send; gboolean ret = TRUE; shout2send = GST_SHOUT2SEND (sink); GST_LOG_OBJECT (shout2send, "got %s event", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG:{ /* vorbis audio doesnt need metadata setting on the icecast level, only mp3 */ if (shout2send->tags && shout2send->audio_format == SHOUT_FORMAT_MP3) { GstTagList *list; gst_event_parse_tag (event, &list); GST_DEBUG_OBJECT (shout2send, "tags=%" GST_PTR_FORMAT, list); gst_tag_list_insert (shout2send->tags, list, gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (shout2send))); /* lets get the artist and song tags */ gst_tag_list_foreach ((GstTagList *) list, set_shout_metadata, shout2send); if (shout2send->songmetadata && shout2send->connected) { shout_metadata_t *pmetadata; GST_DEBUG_OBJECT (shout2send, "metadata now: %s", shout2send->songmetadata); pmetadata = shout_metadata_new (); shout_metadata_add (pmetadata, "song", shout2send->songmetadata); shout_set_metadata (shout2send->conn, pmetadata); shout_metadata_free (pmetadata); } } break; } default:{ GST_LOG_OBJECT (shout2send, "let base class handle event"); if (GST_BASE_SINK_CLASS (parent_class)->event) { event = gst_event_ref (event); ret = GST_BASE_SINK_CLASS (parent_class)->event (sink, event); } break; } } return ret; }
static gboolean event_forward_func (GstPad * pad, EventData * evdata) { gboolean ret = TRUE; GstPad *peer = gst_pad_get_peer (pad); GstAggregatorPadPrivate *padpriv = GST_AGGREGATOR_PAD (pad)->priv; if (peer) { ret = gst_pad_send_event (peer, gst_event_ref (evdata->event)); GST_DEBUG_OBJECT (pad, "return of event push is %d", ret); gst_object_unref (peer); } if (ret == FALSE) { if (GST_EVENT_TYPE (evdata->event) == GST_EVENT_SEEK) GST_ERROR_OBJECT (pad, "Event %" GST_PTR_FORMAT " failed", evdata->event); if (GST_EVENT_TYPE (evdata->event) == GST_EVENT_SEEK) { GstQuery *seeking = gst_query_new_seeking (GST_FORMAT_TIME); if (gst_pad_query (peer, seeking)) { gboolean seekable; gst_query_parse_seeking (seeking, NULL, &seekable, NULL, NULL); if (seekable == FALSE) { GST_INFO_OBJECT (pad, "Source not seekable, We failed but it does not matter!"); ret = TRUE; } } else { GST_ERROR_OBJECT (pad, "Query seeking FAILED"); } } if (evdata->flush) { padpriv->pending_flush_start = FALSE; padpriv->pending_flush_stop = FALSE; } } else { evdata->one_actually_seeked = TRUE; } evdata->result &= ret; /* Always send to all pads */ return FALSE; }
static gboolean copy_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data) { CopyStickyEventsData *data = user_data; if (GST_EVENT_TYPE (*event) >= GST_EVENT_CAPS && data->caps) { gst_pad_set_caps (data->pad, data->caps); data->caps = NULL; } if (GST_EVENT_TYPE (*event) != GST_EVENT_CAPS) gst_pad_push_event (data->pad, gst_event_ref (*event)); return TRUE; }
static gboolean push_event (MpegTSBase * base, GstEvent * event) { MpegTSParse2 *parse = (MpegTSParse2 *) base; GList *tmp; for (tmp = GST_ELEMENT_CAST (parse)->srcpads; tmp; tmp = tmp->next) { GstPad *pad = (GstPad *) tmp->data; if (pad) { gst_event_ref (event); gst_pad_push_event (pad, event); } } return TRUE; }
static gboolean resend_events (GstPad * pad, GstEvent ** event, gpointer user_data) { GstRTPMux *rtp_mux = user_data; if (GST_EVENT_TYPE (*event) == GST_EVENT_CAPS) { GstCaps *caps; gst_event_parse_caps (*event, &caps); gst_rtp_mux_setcaps (pad, rtp_mux, caps); } else { gst_pad_push_event (rtp_mux->srcpad, gst_event_ref (*event)); } return TRUE; }
static gboolean forward_event_func (GstPad * pad, GValue * ret, GstEvent * event) { gst_event_ref (event); GST_LOG_OBJECT (pad, "About to send event %s", GST_EVENT_TYPE_NAME (event)); if (!gst_pad_push_event (pad, event)) { g_value_set_boolean (ret, FALSE); GST_WARNING_OBJECT (pad, "Sending event %p (%s) failed.", event, GST_EVENT_TYPE_NAME (event)); } else { GST_LOG_OBJECT (pad, "Sent event %p (%s).", event, GST_EVENT_TYPE_NAME (event)); } gst_object_unref (pad); return TRUE; }
static gboolean gst_play_sink_convert_bin_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstPlaySinkConvertBin *self = GST_PLAY_SINK_CONVERT_BIN (parent); gboolean ret; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CAPS: { GstCaps *caps; gst_event_parse_caps (event, &caps); ret = gst_play_sink_convert_bin_sink_setcaps (self, caps); break; } default: break; } ret = gst_pad_event_default (pad, parent, gst_event_ref (event)); if (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT) { GstSegment seg; GST_PLAY_SINK_CONVERT_BIN_LOCK (self); gst_event_copy_segment (event, &seg); GST_DEBUG_OBJECT (self, "Segment before %" GST_SEGMENT_FORMAT, &self->segment); self->segment = seg; GST_DEBUG_OBJECT (self, "Segment after %" GST_SEGMENT_FORMAT, &self->segment); GST_PLAY_SINK_CONVERT_BIN_UNLOCK (self); } else if (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP) { GST_PLAY_SINK_CONVERT_BIN_LOCK (self); GST_DEBUG_OBJECT (self, "Resetting segment"); gst_segment_init (&self->segment, GST_FORMAT_UNDEFINED); GST_PLAY_SINK_CONVERT_BIN_UNLOCK (self); } gst_event_unref (event); return ret; }