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;
}
