自学教程：C++ GST_EVENT_TYPE_NAME函数代码示例

static gbooleanopus_dec_src_event (GstPad * pad, GstEvent * event){  gboolean res = FALSE;  GstOpusDec *dec = GST_OPUS_DEC (gst_pad_get_parent (pad));  GST_LOG_OBJECT (dec, "handling %s event", GST_EVENT_TYPE_NAME (event));  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_SEEK:{      GstFormat format, tformat;      gdouble rate;      GstEvent *real_seek;      GstSeekFlags flags;      GstSeekType cur_type, stop_type;      gint64 cur, stop;      gint64 tcur, tstop;      gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur,          &stop_type, &stop);      /* we have to ask our peer to seek to time here as we know       * nothing about how to generate a granulepos from the src       * formats or anything.       *       * First bring the requested format to time       */      tformat = GST_FORMAT_TIME;      if (!(res = opus_dec_convert (pad, format, cur, &tformat, &tcur)))        break;      if (!(res = opus_dec_convert (pad, format, stop, &tformat, &tstop)))        break;      /* then seek with time on the peer */      real_seek = gst_event_new_seek (rate, GST_FORMAT_TIME,          flags, cur_type, tcur, stop_type, tstop);      GST_LOG_OBJECT (dec, "seek to %" GST_TIME_FORMAT, GST_TIME_ARGS (tcur));      res = gst_pad_push_event (dec->sinkpad, real_seek);      gst_event_unref (event);      break;    }    default:      res = gst_pad_event_default (pad, event);      break;  }  gst_object_unref (dec);  return res;}

static gbooleangst_gnome_vfs_sink_handle_event (GstBaseSink * basesink, GstEvent * event){    GstGnomeVFSSink *sink;    gboolean ret = TRUE;    sink = GST_GNOME_VFS_SINK (basesink);    GST_DEBUG_OBJECT (sink, "processing %s event", GST_EVENT_TYPE_NAME (event));    switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_NEWSEGMENT: {        GnomeVFSResult res;        GstFormat format;        gint64 offset;        gst_event_parse_new_segment (event, NULL, NULL, &format, &offset,                                     NULL, NULL);        if (format != GST_FORMAT_BYTES) {            GST_WARNING_OBJECT (sink, "ignored NEWSEGMENT event in %s format",                                gst_format_get_name (format));            break;        }        GST_LOG_OBJECT (sink, "seeking to offset %" G_GINT64_FORMAT, offset);        res = gnome_vfs_seek (sink->handle, GNOME_VFS_SEEK_START, offset);        if (res != GNOME_VFS_OK) {            GST_ERROR_OBJECT (sink, "Failed to seek to offset %"                              G_GINT64_FORMAT ": %s", offset, gnome_vfs_result_to_string (res));            ret = FALSE;        } else {            sink->current_pos = offset;        }        break;    }    case GST_EVENT_FLUSH_START:    case GST_EVENT_EOS: {        /* No need to flush with GnomeVfs */        break;    }    default:        break;    }    return ret;}

/* Event */static gboolean gst_android_video_source_event(GstBaseSrc * p_gstbasesrc, GstEvent * p_event){    gboolean res = TRUE;    GA_LOGTRACE("ENTER %s --xx--> thread(%ld)", __FUNCTION__, pthread_self());    const char* event_name_str = GST_EVENT_TYPE_NAME(p_event);    GA_LOGVERB("%s: Received event: %s", __FUNCTION__, event_name_str);    // Currently doing nothing here...    GA_LOGTRACE("EXIT %s", __FUNCTION__);    return res;}

static gbooleangst_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 gbooleanforward_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data){  GstPad *srcpad = GST_PAD_CAST (user_data);  GstFlowReturn ret;  ret = gst_pad_store_sticky_event (srcpad, *event);  if (ret != GST_FLOW_OK) {    GST_DEBUG_OBJECT (srcpad, "storing sticky event %p (%s) failed: %s", *event,        GST_EVENT_TYPE_NAME (*event), gst_flow_get_name (ret));  }  return TRUE;}

static gbooleangst_base_video_encoder_sink_event (GstPad * pad, GstEvent * event){  GstBaseVideoEncoder *enc;  GstBaseVideoEncoderClass *klass;  gboolean handled = FALSE;  gboolean ret = TRUE;  enc = GST_BASE_VIDEO_ENCODER (gst_pad_get_parent (pad));  klass = GST_BASE_VIDEO_ENCODER_GET_CLASS (enc);  GST_DEBUG_OBJECT (enc, "received event %d, %s", GST_EVENT_TYPE (event),      GST_EVENT_TYPE_NAME (event));  if (klass->event)    handled = klass->event (enc, event);  if (!handled)    handled = gst_base_video_encoder_sink_eventfunc (enc, event);  if (!handled) {    /* Forward non-serialized events and EOS/FLUSH_STOP immediately.     * For EOS this is required because no buffer or serialized event     * will come after EOS and nothing could trigger another     * _finish_frame() call.   *     * If the subclass handles sending of EOS manually it can return     * _DROPPED from ::finish() and all other subclasses should have     * decoded/flushed all remaining data before this     *     * For FLUSH_STOP this is required because it is expected     * to be forwarded immediately and no buffers are queued anyway.     */    if (!GST_EVENT_IS_SERIALIZED (event)        || GST_EVENT_TYPE (event) == GST_EVENT_EOS        || GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP) {      ret = gst_pad_push_event (enc->base_video_codec.srcpad, event);    } else {      GST_BASE_VIDEO_CODEC_STREAM_LOCK (enc);      enc->current_frame_events =          g_list_prepend (enc->current_frame_events, event);      GST_BASE_VIDEO_CODEC_STREAM_UNLOCK (enc);    }  }  GST_DEBUG_OBJECT (enc, "event handled");  gst_object_unref (enc);  return ret;}

static gbooleangst_span_plc_event_sink (GstPad * pad, GstEvent * event){  gboolean ret = FALSE;  GstSpanPlc *plc = GST_SPAN_PLC (gst_pad_get_parent (pad));  GST_DEBUG_OBJECT (plc, "received event %s", GST_EVENT_TYPE_NAME (event));  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_NEWSEGMENT:    {      GstFormat format;      gdouble rate;      gint64 start, stop, time;      gboolean update;      gst_event_parse_new_segment (event, &update, &rate, &format, &start,          &stop, &time);      if (format != GST_FORMAT_TIME)        goto newseg_wrong_format;      if (update) {        /* time progressed without data, see if we can fill the gap with         * some concealment data */        if (plc->last_stop < start)          gst_span_plc_send_fillin (plc, start - plc->last_stop);      }      plc->last_stop = start;      break;    }    case GST_EVENT_FLUSH_START:      gst_span_plc_flush (plc, TRUE);      break;    default:      break;  }  ret = gst_pad_push_event (plc->srcpad, event);  gst_object_unref (plc);  return ret;newseg_wrong_format:  {    GST_DEBUG_OBJECT (plc, "received non TIME newsegment");    gst_object_unref (plc);    return FALSE;  }}

static gbooleangst_jp2k_decimator_event (GstPad * pad, GstEvent * event){  GstJP2kDecimator *self = GST_JP2K_DECIMATOR (gst_pad_get_parent (pad));  GstPad *otherpad;  gboolean ret;  GST_LOG_OBJECT (pad, "Got %s event", GST_EVENT_TYPE_NAME (event));  otherpad = (pad == self->srcpad) ? self->sinkpad : self->srcpad;  ret = gst_pad_push_event (otherpad, event);  gst_object_unref (self);  return ret;}

static voidgst_type_find_element_send_cached_events (GstTypeFindElement * typefind){  GList *l;  for (l = typefind->cached_events; l != NULL; l = l->next) {    GstEvent *event = GST_EVENT (l->data);    GST_DEBUG_OBJECT (typefind, "sending cached %s event",        GST_EVENT_TYPE_NAME (event));    gst_pad_push_event (typefind->src, event);  }  g_list_free (typefind->cached_events);  typefind->cached_events = NULL;}

static gbooleanforward_event_func (GstPad * pad, GValue * ret, EventData * data){  GstEvent *event = data->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)) {    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 ());  } else {    g_value_set_boolean (ret, TRUE);    GST_LOG_OBJECT (pad, "Sent event  %p (%s).",        event, GST_EVENT_TYPE_NAME (event));  }  gst_object_unref (pad);  /* continue on other pads, even if one failed */  return TRUE;}

static gbooleangst_adder_sink_event (GstPad * pad, GstEvent * event){    GstAdder *adder;    gboolean ret = TRUE;    adder = GST_ADDER (gst_pad_get_parent (pad));    GST_DEBUG ("Got %s event on pad %s:%s", GST_EVENT_TYPE_NAME (event),               GST_DEBUG_PAD_NAME (pad));    switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_FLUSH_STOP:        /* we received a flush-stop. The collect_event function will push the         * event past our element. We simply forward all flush-stop events, even         * when no flush-stop was pending, this is required because collectpads         * does not provide an API to handle-but-not-forward the flush-stop.         * We unset the pending flush-stop flag so that we don't send anymore         * flush-stop from the collect function later.         */        GST_OBJECT_LOCK (adder->collect);        adder->segment_pending = TRUE;        adder->flush_stop_pending = FALSE;        /* Clear pending tags */        if (adder->pending_events) {            g_list_foreach (adder->pending_events, (GFunc) gst_event_unref, NULL);            g_list_free (adder->pending_events);            adder->pending_events = NULL;        }        GST_OBJECT_UNLOCK (adder->collect);        break;    case GST_EVENT_TAG:        GST_OBJECT_LOCK (adder->collect);        /* collect tags here so we can push them out when we collect data */        adder->pending_events = g_list_append (adder->pending_events, event);        GST_OBJECT_UNLOCK (adder->collect);        goto beach;    default:        break;    }    /* now GstCollectPads can take care of the rest, e.g. EOS */    ret = adder->collect_event (pad, event);beach:    gst_object_unref (adder);    return ret;}

static voiddo_push_event_pre (GstStatsTracer * self, guint64 ts, GstPad * pad,    GstEvent * ev){  GstElement *elem = get_real_pad_parent (pad);  GstElementStats *elem_stats = get_element_stats (self, elem);  GstPadStats *pad_stats = get_pad_stats (self, pad);  elem_stats->last_ts = ts;  gst_tracer_log_trace (gst_structure_new ("event",          "thread-id", G_TYPE_UINT, GPOINTER_TO_UINT (g_thread_self ()),          "ts", G_TYPE_UINT64, ts,          "pad-ix", G_TYPE_UINT, pad_stats->index,          "elem-ix", G_TYPE_UINT, elem_stats->index,          "name", G_TYPE_STRING, GST_EVENT_TYPE_NAME (ev), NULL));}

static gboolean gst_rrparser_sink_event(GstPad *pad, GstEvent *event){    GstRRParser * rrparser =(GstRRParser *) gst_pad_get_parent(pad);	gboolean ret = FALSE;    GST_DEBUG("pad /"%s/" received:  %s/n", GST_PAD_NAME(pad),        GST_EVENT_TYPE_NAME(event));    switch (GST_EVENT_TYPE(event)) {		case GST_EVENT_EOS:			ret = gst_pad_push_event(rrparser->src_pad, event);			break;		default:			ret = gst_pad_push_event(rrparser->src_pad, event);    }    return ret;}

static gbooleanhandle_event (GstBaseSink *gst_base,              GstEvent *event){    GstOmxBaseSink *self;    GOmxCore *gomx;    GOmxPort *in_port;    self = GST_OMX_BASE_SINK (gst_base);    gomx = self->gomx;    in_port = self->in_port;    GST_LOG_OBJECT (self, "begin");    GST_DEBUG_OBJECT (self, "event: %s", GST_EVENT_TYPE_NAME (event));    switch (GST_EVENT_TYPE (event))    {        case GST_EVENT_EOS:            /* Close the inpurt port. */            g_omx_core_set_done (gomx);            break;        case GST_EVENT_FLUSH_START:            /* unlock loops */            g_omx_port_pause (in_port);            /* flush all buffers */            OMX_SendCommand (gomx->omx_handle, OMX_CommandFlush, OMX_ALL, NULL);            break;        case GST_EVENT_FLUSH_STOP:            g_sem_down (gomx->flush_sem);            g_omx_port_resume (in_port);            break;        default:            break;    }    GST_LOG_OBJECT (self, "end");    return TRUE;}

static gbooleangst_fluid_dec_sink_event (GstPad * pad, GstObject * parent, GstEvent * event){  gboolean res;  GstFluidDec *fluiddec = GST_FLUID_DEC (parent);  GST_DEBUG_OBJECT (pad, "%s event received", GST_EVENT_TYPE_NAME (event));  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_CAPS:    {      GstCaps *caps;      caps = gst_caps_new_simple ("audio/x-raw",          "format", G_TYPE_STRING, GST_AUDIO_NE (F32),          "rate", G_TYPE_INT, FLUID_DEC_RATE,          "channels", G_TYPE_INT, 2,          "layout", G_TYPE_STRING, "interleaved", NULL);      fluid_synth_set_sample_rate (fluiddec->synth, FLUID_DEC_RATE);      res = gst_pad_push_event (fluiddec->srcpad, gst_event_new_caps (caps));      gst_caps_unref (caps);      break;    }    case GST_EVENT_SEGMENT:      gst_event_copy_segment (event, &fluiddec->segment);      GST_DEBUG_OBJECT (fluiddec, "configured segment %" GST_SEGMENT_FORMAT,          &fluiddec->segment);      res = gst_pad_event_default (pad, parent, event);      break;    case GST_EVENT_FLUSH_STOP:      gst_fluid_dec_reset (fluiddec);      res = gst_pad_event_default (pad, parent, event);      break;    case GST_EVENT_EOS:      /* FIXME, push last samples */      res = gst_pad_event_default (pad, parent, event);      break;    default:      res = gst_pad_event_default (pad, parent, event);      break;  }  return res;}

static gbooleangst_vr_compositor_src_event (GstBaseTransform * trans, GstEvent * event){  GstVRCompositor *self = GST_VR_COMPOSITOR (trans);  GST_DEBUG_OBJECT (trans, "handling %s event", GST_EVENT_TYPE_NAME (event));  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_NAVIGATION:      event =          GST_EVENT (gst_mini_object_make_writable (GST_MINI_OBJECT (event)));      gst_3d_scene_send_eos_on_esc (GST_ELEMENT (self), event);      gst_3d_scene_navigation_event (self->scene, event);      break;    default:      break;  }  return GST_BASE_TRANSFORM_CLASS (parent_class)->src_event (trans, event);}

static gbooleangst_deinterlace2_src_event (GstPad * pad, GstEvent * event){  GstDeinterlace2 *self = GST_DEINTERLACE2 (gst_pad_get_parent (pad));  gboolean res;  GST_DEBUG_OBJECT (pad, "received %s event", GST_EVENT_TYPE_NAME (event));  switch (GST_EVENT_TYPE (event)) {    default:      res = gst_pad_event_default (pad, event);      break;  }  gst_object_unref (self);  return res;}

static gbooleangst_dasf_sink_event (GstBaseSink *bsink, GstEvent *event){	GST_INFO ("%s", GST_EVENT_TYPE_NAME (event));	switch (GST_EVENT_TYPE (event))	{	case GST_EVENT_EOS:		gst_element_send_event (GST_ELEMENT (bsink),				gst_goo_event_new_reverse_eos() );		break;	default:		break;	}	/* we don't want to bypass GstBaseSink's handling of the event: */	return TRUE;}

static gbooleangst_deinterleave_sink_event (GstPad * pad, GstObject * parent, GstEvent * event){  GstDeinterleave *self = GST_DEINTERLEAVE (parent);  gboolean ret;  GST_DEBUG ("Got %s event on pad %s:%s", GST_EVENT_TYPE_NAME (event),      GST_DEBUG_PAD_NAME (pad));  /* Send FLUSH_STOP, FLUSH_START and EOS immediately, no matter if   * we have src pads already or not. Queue all other events and   * push them after we have src pads   */  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_FLUSH_STOP:    case GST_EVENT_FLUSH_START:    case GST_EVENT_EOS:      ret = gst_pad_event_default (pad, parent, event);      break;    case GST_EVENT_CAPS:    {      GstCaps *caps;      gst_event_parse_caps (event, &caps);      ret = gst_deinterleave_sink_setcaps (self, caps);      gst_event_unref (event);      break;    }    default:      if (!self->srcpads && !GST_EVENT_IS_STICKY (event)) {        /* Sticky events are copied when creating a new pad */        GST_OBJECT_LOCK (self);        self->pending_events = g_list_append (self->pending_events, event);        GST_OBJECT_UNLOCK (self);        ret = TRUE;      } else {        ret = gst_pad_event_default (pad, parent, event);      }      break;  }  return ret;}

/** * @brief This function handles sink events. */static gbooleangst_tensor_aggregator_sink_event (GstPad * pad, GstObject * parent,    GstEvent * event){  GstTensorAggregator *self;  self = GST_TENSOR_AGGREGATOR (parent);  GST_DEBUG_OBJECT (self, "Received %s event: %" GST_PTR_FORMAT,      GST_EVENT_TYPE_NAME (event), event);  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_CAPS:    {      GstCaps *in_caps;      GstCaps *out_caps;      gst_event_parse_caps (event, &in_caps);      silent_debug_caps (in_caps, "in-caps");      if (gst_tensor_aggregator_parse_caps (self, in_caps)) {        out_caps = gst_tensor_caps_from_config (&self->out_config);        silent_debug_caps (out_caps, "out-caps");        gst_pad_set_caps (self->srcpad, out_caps);        gst_event_unref (event);        event = gst_event_new_caps (out_caps);        gst_caps_unref (out_caps);        return gst_pad_push_event (self->srcpad, event);      }      break;    }    case GST_EVENT_FLUSH_STOP:      gst_tensor_aggregator_reset (self);      break;    default:      break;  }  return gst_pad_event_default (pad, parent, event);}

static gbooleangst_dtsdec_sink_event (GstPad * pad, GstEvent * event){  GstDtsDec *dtsdec = GST_DTSDEC (gst_pad_get_parent (pad));  gboolean ret = FALSE;  GST_LOG_OBJECT (dtsdec, "%s event", GST_EVENT_TYPE_NAME (event));  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_NEWSEGMENT:{      GstFormat format;      gint64 val;      gst_event_parse_new_segment (event, NULL, NULL, &format, &val, NULL,          NULL);      if (format != GST_FORMAT_TIME || !GST_CLOCK_TIME_IS_VALID (val)) {        GST_WARNING ("No time in newsegment event %p", event);      } else {        dtsdec->current_ts = val;      }      if (dtsdec->cache) {        gst_buffer_unref (dtsdec->cache);        dtsdec->cache = NULL;      }      ret = gst_pad_event_default (pad, event);      break;    }    case GST_EVENT_FLUSH_STOP:      if (dtsdec->cache) {        gst_buffer_unref (dtsdec->cache);        dtsdec->cache = NULL;      }      ret = gst_pad_event_default (pad, event);      break;    default:      ret = gst_pad_event_default (pad, event);      break;  }  gst_object_unref (dtsdec);  return ret;}

static gbooleangst_shape_wipe_video_sink_event (GstPad * pad, GstObject * parent,    GstEvent * event){  GstShapeWipe *self = GST_SHAPE_WIPE (parent);  gboolean ret;  GST_LOG_OBJECT (pad, "Got %s event", GST_EVENT_TYPE_NAME (event));  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_CAPS:    {      GstCaps *caps;      gst_event_parse_caps (event, &caps);      ret = gst_shape_wipe_video_sink_setcaps (self, caps);      gst_event_unref (event);      break;    }    case GST_EVENT_SEGMENT:    {      GstSegment seg;      gst_event_copy_segment (event, &seg);      if (seg.format == GST_FORMAT_TIME) {        GST_DEBUG_OBJECT (pad,            "Got SEGMENT event in GST_FORMAT_TIME %" GST_PTR_FORMAT, &seg);        self->segment = seg;      } else {        gst_segment_init (&self->segment, GST_FORMAT_TIME);      }    }      /* fall through */    case GST_EVENT_FLUSH_STOP:      gst_shape_wipe_reset_qos (self);      /* fall through */    default:      ret = gst_pad_push_event (self->srcpad, event);      break;  }  return ret;}

static gbooleangst_midi_parse_src_event (GstPad * pad, GstObject * parent, GstEvent * event){  gboolean res = FALSE;  GstMidiParse *midiparse = GST_MIDI_PARSE (parent);  GST_DEBUG_OBJECT (pad, "%s event received", GST_EVENT_TYPE_NAME (event));  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_SEEK:      res = gst_midi_parse_perform_seek (midiparse, event);      break;    default:      break;  }  gst_event_unref (event);  return res;}

static gbooleangst_segment_clip_event (GstPad * pad, GstObject * parent, GstEvent * event){  GstSegmentClip *self = GST_SEGMENT_CLIP (parent);  gboolean ret = TRUE;  GST_LOG_OBJECT (pad, "Got %s event", GST_EVENT_TYPE_NAME (event));  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_CAPS:    {      GstCaps *caps;      /* should be only downstream */      g_assert (pad == self->sinkpad);      gst_event_parse_caps (event, &caps);      ret = gst_segment_clip_sink_setcaps (self, caps);      break;    }    case GST_EVENT_SEGMENT:    {      const GstSegment *segment;      gst_event_parse_segment (event, &segment);      GST_DEBUG_OBJECT (pad, "Got NEWSEGMENT event %" GST_SEGMENT_FORMAT,          segment);      gst_segment_copy_into (segment, &self->segment);      break;    }    case GST_EVENT_FLUSH_STOP:      gst_segment_clip_reset (self);      break;    default:      break;  }  if (ret)    ret = gst_pad_event_default (pad, parent, event);  else    gst_event_unref (event);  return ret;}

static gbooleanforward_event (GstInterleave * self, GstEvent * event){  GstIterator *it;  GValue vret = { 0 };  GST_LOG_OBJECT (self, "Forwarding event %p (%s)", event,      GST_EVENT_TYPE_NAME (event));  g_value_init (&vret, G_TYPE_BOOLEAN);  g_value_set_boolean (&vret, TRUE);  it = gst_element_iterate_sink_pads (GST_ELEMENT_CAST (self));  gst_iterator_fold (it, (GstIteratorFoldFunction) forward_event_func, &vret,      event);  gst_iterator_free (it);  gst_event_unref (event);  return g_value_get_boolean (&vret);}

static gboolean gst_pgmdec_sink_event (GstPad * pad, GstEvent * event){	gboolean ret = TRUE;	Gstpgmdec *filter = GST_PGMDEC (GST_OBJECT_PARENT (pad));	GST_DEBUG_OBJECT (filter, "event : %s", GST_EVENT_TYPE_NAME (event));  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_FLUSH_STOP:{      GST_DEBUG_OBJECT (filter, "Aborting decompress");      //jpeg_abort_decompress (&dec->cinfo);      gst_segment_init (&filter->segment, GST_FORMAT_UNDEFINED);      //gst_jpeg_dec_reset_qos (dec);      break;    }    case GST_EVENT_NEWSEGMENT:{      gboolean update;      gdouble rate, applied_rate;      GstFormat format;      gint64 start, stop, position;      gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate,          &format, &start, &stop, &position);      GST_DEBUG_OBJECT (filter, "Got NEWSEGMENT [%" GST_TIME_FORMAT          " - %" GST_TIME_FORMAT " / %" GST_TIME_FORMAT "]",          GST_TIME_ARGS (start), GST_TIME_ARGS (stop),          GST_TIME_ARGS (position));      gst_segment_set_newsegment_full (&filter->segment, update, rate,          applied_rate, format, start, stop, position);      break;    }    default:      break;  }  ret = gst_pad_push_event (filter->srcpad, event);  return ret;}

static gbooleangst_image_freeze_sink_event (GstPad * pad, GstObject * parent, GstEvent * event){    GstImageFreeze *self = GST_IMAGE_FREEZE (parent);    gboolean ret;    GST_LOG_OBJECT (pad, "Got %s event", GST_EVENT_TYPE_NAME (event));    switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_CAPS:    {        GstCaps *caps;        gst_event_parse_caps (event, &caps);        gst_image_freeze_sink_setcaps (self, caps);        gst_event_unref (event);        ret = TRUE;        break;    }    case GST_EVENT_EOS:        if (!self->buffer) {            /* if we receive EOS before a buffer arrives, then let it pass */            GST_DEBUG_OBJECT (self, "EOS without input buffer, passing on");            ret = gst_pad_push_event (self->srcpad, event);            break;        }    /* fall-through */    case GST_EVENT_SEGMENT:        GST_DEBUG_OBJECT (pad, "Dropping event");        gst_event_unref (event);        ret = TRUE;        break;    case GST_EVENT_FLUSH_START:        gst_image_freeze_reset (self);    /* fall through */    default:        ret = gst_pad_push_event (self->srcpad, event);        break;    }    return ret;}

static gbooleangst_segment_clip_event (GstPad * pad, GstEvent * event){  GstSegmentClip *self = GST_SEGMENT_CLIP (gst_pad_get_parent (pad));  GstPad *otherpad;  gboolean ret;  GST_LOG_OBJECT (pad, "Got %s event", GST_EVENT_TYPE_NAME (event));  otherpad = (pad == self->srcpad) ? self->sinkpad : self->srcpad;  ret = gst_pad_push_event (otherpad, event);  if (ret) {    switch (GST_EVENT_TYPE (event)) {      case GST_EVENT_NEWSEGMENT:{        GstFormat fmt;        gboolean is_update;        gint64 start, end, base;        gdouble rate;        gst_event_parse_new_segment (event, &is_update, &rate, &fmt, &start,            &end, &base);        GST_DEBUG_OBJECT (pad,            "Got NEWSEGMENT event in %s format, passing on (%"            GST_TIME_FORMAT " - %" GST_TIME_FORMAT ")",            gst_format_get_name (fmt), GST_TIME_ARGS (start),            GST_TIME_ARGS (end));        gst_segment_set_newsegment (&self->segment, is_update, rate, fmt, start,            end, base);        break;      }      case GST_EVENT_FLUSH_STOP:        gst_segment_clip_reset (self);        break;      default:        break;    }  }  gst_object_unref (self);  return ret;}

static void_gst_event_free (GstEvent * event){  GstStructure *s;  g_return_if_fail (event != NULL);  g_return_if_fail (GST_IS_EVENT (event));  GST_CAT_LOG (GST_CAT_EVENT, "freeing event %p type %s", event,      GST_EVENT_TYPE_NAME (event));  s = GST_EVENT_STRUCTURE (event);  if (s) {    gst_structure_set_parent_refcount (s, NULL);    gst_structure_free (s);  }  g_slice_free1 (sizeof (GstEventImpl), event);}