static gboolean gst_a2dp_sink_handle_event (GstPad * pad, GstObject * pad_parent, GstEvent * event) { GstA2dpSink *self; GstTagList *taglist = NULL; self = GST_A2DP_SINK (pad_parent); if (GST_EVENT_TYPE (event) == GST_EVENT_TAG) { 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); } } else if (GST_EVENT_TYPE (event) == GST_EVENT_CAPS) { GstCaps *caps = NULL; gst_event_parse_caps (event, &caps); gst_a2dp_sink_init_dynamic_elements (self, caps); } return gst_pad_event_default (pad, pad_parent, 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 gst_ffmpegmux_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstFFMpegMux *ffmpegmux = (GstFFMpegMux *) parent; gboolean res = TRUE; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG:{ GstTagList *taglist; GstTagSetter *setter = GST_TAG_SETTER (ffmpegmux); const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter); gst_event_parse_tag (event, &taglist); gst_tag_setter_merge_tags (setter, taglist, mode); break; } case GST_EVENT_CAPS:{ GstCaps *caps; gst_event_parse_caps (event, &caps); if (!(res = gst_ffmpegmux_setcaps (pad, caps))) goto beach; break; } default: break; } /* chaining up to collectpads default event function */ res = ffmpegmux->event_function (pad, parent, event); beach: return res; }
static GstEvent * send_tag_event (GstElement * element, GstEvent * event) { g_return_val_if_fail (event->type == GST_EVENT_TAG, NULL); fail_unless (g_list_length (events) == 0); fail_unless (gst_pad_push_event (mysrcpad, event), "Pushing tag event failed"); if (g_list_length (events) == 0) { /* Event got filtered out. */ event = NULL; } else { GstTagList *tag_list; gdouble dummy; event = events->data; events = g_list_remove (events, event); fail_unless (event->type == GST_EVENT_TAG); gst_event_parse_tag (event, &tag_list); /* The element is supposed to filter out ReplayGain related tags. */ fail_if (gst_tag_list_get_double (tag_list, GST_TAG_TRACK_GAIN, &dummy), "tag event still contains track gain tag"); fail_if (gst_tag_list_get_double (tag_list, GST_TAG_TRACK_PEAK, &dummy), "tag event still contains track peak tag"); fail_if (gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_GAIN, &dummy), "tag event still contains album gain tag"); fail_if (gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_PEAK, &dummy), "tag event still contains album peak tag"); } return event; }
static gboolean gst_speex_enc_sink_event (GstAudioEncoder * benc, GstEvent * event) { GstSpeexEnc *enc; enc = GST_SPEEX_ENC (benc); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG: { if (enc->tags) { GstTagList *list; gst_event_parse_tag (event, &list); gst_tag_list_insert (enc->tags, list, gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (enc))); } else { g_assert_not_reached (); } break; } default: break; } /* we only peeked, let base class handle it */ return GST_AUDIO_ENCODER_CLASS (parent_class)->sink_event (benc, event); }
static gboolean gst_rg_analysis_sink_event (GstBaseTransform * base, GstEvent * event) { GstRgAnalysis *filter = GST_RG_ANALYSIS (base); g_return_val_if_fail (filter->ctx != NULL, TRUE); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: { GST_LOG_OBJECT (filter, "received EOS event"); gst_rg_analysis_handle_eos (filter); GST_LOG_OBJECT (filter, "passing on EOS event"); break; } case GST_EVENT_TAG: { GstTagList *tag_list; /* The reference to the tag list is borrowed. */ gst_event_parse_tag (event, &tag_list); gst_rg_analysis_handle_tags (filter, tag_list); break; } default: break; } return GST_BASE_TRANSFORM_CLASS (parent_class)->sink_event (base, event); }
static gboolean gst_vorbis_enc_sink_event (GstAudioEncoder * enc, GstEvent * event) { GstVorbisEnc *vorbisenc; vorbisenc = GST_VORBISENC (enc); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG: if (vorbisenc->tags) { GstTagList *list; gst_event_parse_tag (event, &list); gst_tag_list_insert (vorbisenc->tags, list, gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (vorbisenc))); } else { g_assert_not_reached (); } break; /* fall through */ default: break; } /* we only peeked, let base class handle it */ return GST_AUDIO_ENCODER_CLASS (parent_class)->sink_event (enc, event); }
static gboolean get_info_from_tags (GstPad * pad, GstEvent ** event, gpointer user_data) { GstSDPMedia *media = (GstSDPMedia *) user_data; if (GST_EVENT_TYPE (*event) == GST_EVENT_TAG) { GstTagList *tags; guint bitrate = 0; gst_event_parse_tag (*event, &tags); if (gst_tag_list_get_scope (tags) != GST_TAG_SCOPE_STREAM) return TRUE; if (!gst_tag_list_get_uint (tags, GST_TAG_MAXIMUM_BITRATE, &bitrate) || bitrate == 0) if (!gst_tag_list_get_uint (tags, GST_TAG_BITRATE, &bitrate) || bitrate == 0) return TRUE; /* set bandwidth (kbits/s) */ gst_sdp_media_add_bandwidth (media, GST_SDP_BWTYPE_AS, bitrate / 1000); return FALSE; } return TRUE; }
static gboolean gst_h263_parse_sink_event (GstBaseParse * parse, GstEvent * event) { GstH263Parse *h263parse; gboolean res = FALSE; h263parse = GST_H263_PARSE (parse); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG: { GstTagList *taglist; gst_event_parse_tag (event, &taglist); if (gst_tag_list_get_uint (taglist, GST_TAG_BITRATE, &h263parse->bitrate)) GST_DEBUG_OBJECT (h263parse, "got bitrate tag: %u", h263parse->bitrate); break; } default: break; } return res; }
static gboolean gst_vorbis_enc_sink_event (GstPad * pad, GstEvent * event) { gboolean res = TRUE; GstVorbisEnc *vorbisenc; vorbisenc = GST_VORBISENC (GST_PAD_PARENT (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: /* Tell the library we're at end of stream so that it can handle * the last frame and mark end of stream in the output properly */ GST_DEBUG_OBJECT (vorbisenc, "EOS, clearing state and sending event on"); gst_vorbis_enc_clear (vorbisenc); res = gst_pad_push_event (vorbisenc->srcpad, event); break; case GST_EVENT_TAG: if (vorbisenc->tags) { GstTagList *list; gst_event_parse_tag (event, &list); gst_tag_list_insert (vorbisenc->tags, list, gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (vorbisenc))); } else { g_assert_not_reached (); } res = gst_pad_push_event (vorbisenc->srcpad, event); break; default: res = gst_pad_push_event (vorbisenc->srcpad, event); break; } return res; }
static gboolean gst_vdp_sink_event (GstBaseSink * sink, GstEvent * event) { VdpSink *vdp_sink = GST_VDP_SINK (sink); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG:{ GstTagList *l; gchar *title = NULL; gst_event_parse_tag (event, &l); gst_tag_list_get_string (l, GST_TAG_TITLE, &title); if (title) { GST_DEBUG_OBJECT (vdp_sink, "got tags, title='%s'", title); gst_vdp_sink_window_set_title (vdp_sink, vdp_sink->window, title); g_free (title); } break; } default: break; } if (GST_BASE_SINK_CLASS (parent_class)->event) return GST_BASE_SINK_CLASS (parent_class)->event (sink, event); else return TRUE; }
static gboolean gst_icydemux_handle_event (GstPad * pad, GstEvent * event) { GstICYDemux *icydemux = GST_ICYDEMUX (GST_PAD_PARENT (pad)); gboolean result; if (GST_EVENT_TYPE (event) == GST_EVENT_TAG) { GstTagList *tags; gst_event_parse_tag (event, &tags); result = gst_icydemux_tag_found (icydemux, gst_tag_list_copy (tags)); gst_event_unref (event); return result; } if (icydemux->typefinding) { switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: g_list_foreach (icydemux->cached_events, (GFunc) gst_mini_object_unref, NULL); g_list_free (icydemux->cached_events); icydemux->cached_events = NULL; return gst_pad_event_default (pad, event); default: icydemux->cached_events = g_list_append (icydemux->cached_events, event); return TRUE; } } else { return gst_pad_event_default (pad, event); } }
static gboolean gst_ffmpegmux_sink_event (GstPad * pad, GstEvent * event) { GstFFMpegMux *ffmpegmux = (GstFFMpegMux *) gst_pad_get_parent (pad); gboolean res = TRUE; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG:{ GstTagList *taglist; GstTagSetter *setter = GST_TAG_SETTER (ffmpegmux); const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter); gst_event_parse_tag (event, &taglist); gst_tag_setter_merge_tags (setter, taglist, mode); break; } default: break; } /* chaining up to collectpads default event function */ res = ffmpegmux->event_function (pad, event); gst_object_unref (ffmpegmux); return res; }
static gboolean gst_celt_enc_sink_event (GstAudioEncoder * benc, GstEvent * event) { GstCeltEnc *enc; enc = GST_CELT_ENC (benc); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG: { GstTagList *list; GstTagSetter *setter = GST_TAG_SETTER (enc); const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter); gst_event_parse_tag (event, &list); gst_tag_setter_merge_tags (setter, list, mode); break; } default: break; } /* we only peeked, let base class handle it */ return FALSE; }
static gboolean _event_probe (GstPad * pad, GstEvent * event, PrivateStream * ps) { if (GST_EVENT_TYPE (event) == GST_EVENT_TAG) { GstTagList *tl = NULL, *tmp; gst_event_parse_tag (event, &tl); GST_DEBUG_OBJECT (pad, "tags %" GST_PTR_FORMAT, tl); DISCO_LOCK (ps->dc); /* If preroll is complete, drop these tags - the collected information is * possibly already being processed and adding more tags would be racy */ if (G_LIKELY (ps->dc->priv->processing)) { GST_DEBUG_OBJECT (pad, "private stream %p old tags %" GST_PTR_FORMAT, ps, ps->tags); tmp = gst_tag_list_merge (ps->tags, tl, GST_TAG_MERGE_APPEND); if (ps->tags) gst_tag_list_free (ps->tags); ps->tags = tmp; GST_DEBUG_OBJECT (pad, "private stream %p new tags %" GST_PTR_FORMAT, ps, tmp); } else GST_DEBUG_OBJECT (pad, "Dropping tags since preroll is done"); DISCO_UNLOCK (ps->dc); } return TRUE; }
static gboolean gst_opus_enc_sink_event (GstAudioEncoder * benc, GstEvent * event) { GstOpusEnc *enc; enc = GST_OPUS_ENC (benc); GST_DEBUG_OBJECT (enc, "sink event: %s", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG: { GstTagList *list; GstTagSetter *setter = GST_TAG_SETTER (enc); const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter); gst_event_parse_tag (event, &list); gst_tag_setter_merge_tags (setter, list, mode); break; } default: break; } return FALSE; }
static VALUE tag_parse(VALUE self) { GstTagList *taglist; gst_event_parse_tag(RGST_EVENT(self), &taglist); return GST_STRUCT2RVAL(taglist); }
static gboolean gst_jpeg_parse_sink_event (GstPad * pad, GstEvent * event) { GstJpegParse *parse; gboolean res = TRUE; parse = GST_JPEG_PARSE (gst_pad_get_parent (pad)); GST_DEBUG_OBJECT (parse, "event : %s", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: parse->priv->next_ts = GST_CLOCK_TIME_NONE; parse->priv->duration = GST_CLOCK_TIME_NONE; parse->priv->last_offset = 0; parse->priv->last_entropy_len = 0; parse->priv->last_resync = FALSE; gst_adapter_clear (parse->priv->adapter); break; case GST_EVENT_EOS:{ /* Push the remaining data, even though it's incomplete */ guint available = gst_adapter_available (parse->priv->adapter); if (available > 0) gst_jpeg_parse_push_buffer (parse, available); res = gst_pad_push_event (parse->priv->srcpad, event); break; } case GST_EVENT_NEWSEGMENT: /* Discard any data in the adapter. There should have been an EOS before * to flush it. */ gst_adapter_clear (parse->priv->adapter); res = gst_pad_push_event (parse->priv->srcpad, event); parse->priv->new_segment = TRUE; break; case GST_EVENT_TAG:{ if (!parse->priv->new_segment) res = gst_pad_event_default (pad, event); else { GstTagList *taglist = NULL; gst_event_parse_tag (event, &taglist); /* Hold on to the tags till the srcpad caps are definitely set */ gst_tag_list_insert (get_tag_list (parse), taglist, GST_TAG_MERGE_REPLACE); GST_DEBUG ("collected tags: %" GST_PTR_FORMAT, parse->priv->tags); gst_event_unref (event); } break; } default: res = gst_pad_event_default (pad, event); break; } gst_object_unref (parse); return res; }
static gboolean sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { GST_DEBUG_OBJECT (pad, "Got %s event %p: %" GST_PTR_FORMAT, GST_EVENT_TYPE_NAME (event), event, event); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: if (loop) { while (!g_main_loop_is_running (loop)); } have_eos = TRUE; if (loop) g_main_loop_quit (loop); break; case GST_EVENT_CAPS: { GstCaps *caps; gst_event_parse_caps (event, &caps); sink_check_caps (pad, caps); break; } case GST_EVENT_TAG: { int i, ret; gchar *buf = NULL; GstTagList *aiff_tags = NULL; const gchar *tags[][2] = { {"title", "Title"}, {"artist", "Artist"}, }; gst_event_parse_tag (event, &aiff_tags); fail_unless (aiff_tags != NULL); for (i = 0; i < sizeof (tags) / sizeof (*tags); i++) { buf = NULL; fail_unless (gst_tag_list_get_string (aiff_tags, tags[i][0], &buf)); ret = g_strcmp0 (buf, tags[i][1]); g_free (buf); fail_unless (ret == 0); } have_tags = TRUE; break; } default: break; } gst_event_unref (event); return TRUE; }
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 gst_avdtp_sink_event(GstBaseSink *basesink, GstEvent *event) { GstAvdtpSink *self = GST_AVDTP_SINK(basesink); GstTagList *taglist = NULL; if (GST_EVENT_TYPE(event) == GST_EVENT_TAG) { /* we check the tags, mp3 has tags that are importants and * are outside caps */ gst_event_parse_tag(event, &taglist); gst_tag_list_foreach(taglist, gst_avdtp_sink_tag, self); } return TRUE; }
static gboolean gst_vp8_enc_sink_event (GstBaseVideoEncoder * benc, GstEvent * event) { GstVP8Enc *enc = GST_VP8_ENC (benc); if (GST_EVENT_TYPE (event) == GST_EVENT_TAG) { GstTagList *list; GstTagSetter *setter = GST_TAG_SETTER (enc); const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter); gst_event_parse_tag (event, &list); gst_tag_setter_merge_tags (setter, list, mode); } /* just peeked, baseclass handles the rest */ return FALSE; }
static gboolean gst_vp8_enc_sink_event (GstPad * pad, GstEvent * event) { GstVP8Enc *enc = GST_VP8_ENC (gst_pad_get_parent (pad)); gboolean ret; if (GST_EVENT_TYPE (event) == GST_EVENT_TAG) { GstTagList *list; GstTagSetter *setter = GST_TAG_SETTER (enc); const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter); gst_event_parse_tag (event, &list); gst_tag_setter_merge_tags (setter, list, mode); } ret = enc->base_sink_event_func (pad, event); gst_object_unref (enc); return ret; }
static GstPadProbeReturn tag_event_probe (GstPad * pad, GstPadProbeInfo * info, gpointer data) { GstEvent *event = gst_pad_probe_info_get_event (info); if (GST_EVENT_TYPE (event) == GST_EVENT_TAG) { KmsEncTreeBin *self = data; GstTagList *taglist; guint bitrate; gst_event_parse_tag (event, &taglist); if (gst_tag_list_get_uint (taglist, "bitrate", &bitrate)) { self->priv->tag_bitrate = bitrate; kms_enc_tree_bin_set_target_bitrate (self); } } return GST_PAD_PROBE_OK; }
static gboolean cb_probe (GstPad * pad, GstEvent * e, gpointer user_data) { GstStreamInfo *info = user_data; if (GST_EVENT_TYPE (e) == GST_EVENT_TAG) { gchar *codec, *lang; GstTagList *list; gst_event_parse_tag (e, &list); if (info->type != GST_STREAM_TYPE_AUDIO && gst_tag_list_get_string (list, GST_TAG_VIDEO_CODEC, &codec)) { g_free (info->codec); info->codec = codec; GST_LOG_OBJECT (pad, "codec = %s (video)", codec); g_object_notify (G_OBJECT (info), "codec"); } else if (info->type != GST_STREAM_TYPE_VIDEO && gst_tag_list_get_string (list, GST_TAG_AUDIO_CODEC, &codec)) { g_free (info->codec); info->codec = codec; GST_LOG_OBJECT (pad, "codec = %s (audio)", codec); g_object_notify (G_OBJECT (info), "codec"); } else if (gst_tag_list_get_string (list, GST_TAG_CODEC, &codec)) { g_free (info->codec); info->codec = codec; GST_LOG_OBJECT (pad, "codec = %s (generic)", codec); g_object_notify (G_OBJECT (info), "codec"); } if (gst_tag_list_get_string (list, GST_TAG_LANGUAGE_CODE, &lang)) { g_free (info->langcode); info->langcode = lang; GST_LOG_OBJECT (pad, "language-code = %s", lang); g_object_notify (G_OBJECT (info), "language-code"); } } return TRUE; }
void InbandTextTrackPrivateGStreamer::notifyTrackOfTagsChanged() { m_tagTimerHandler = 0; if (!m_pad) return; String label; String language; GRefPtr<GstEvent> event; for (guint i = 0; (event = adoptGRef(gst_pad_get_sticky_event(m_pad.get(), GST_EVENT_TAG, i))); ++i) { GstTagList* tags = 0; gst_event_parse_tag(event.get(), &tags); ASSERT(tags); gchar* tagValue; if (gst_tag_list_get_string(tags, GST_TAG_TITLE, &tagValue)) { INFO_MEDIA_MESSAGE("Text track %d got title %s.", m_index, tagValue); label = tagValue; g_free(tagValue); } if (gst_tag_list_get_string(tags, GST_TAG_LANGUAGE_CODE, &tagValue)) { INFO_MEDIA_MESSAGE("Text track %d got language %s.", m_index, tagValue); language = tagValue; g_free(tagValue); } } if (m_label != label) { m_label = label; client()->labelChanged(this, m_label); } if (m_language != language) { m_language = language; client()->languageChanged(this, m_language); } }
static gboolean gst_jif_mux_sink_event (GstPad * pad, GstEvent * event) { GstJifMux *self = GST_JIF_MUX (GST_PAD_PARENT (pad)); gboolean ret; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG: { GstTagList *list; GstTagSetter *setter = GST_TAG_SETTER (self); const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter); gst_event_parse_tag (event, &list); gst_tag_setter_merge_tags (setter, list, mode); break; } default: break; } ret = gst_pad_event_default (pad, event); return ret; }
static gboolean gst_speex_enc_sinkevent (GstPad * pad, GstEvent * event) { gboolean res = TRUE; GstSpeexEnc *enc; enc = GST_SPEEX_ENC (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: if (enc->setup) gst_speex_enc_encode (enc, TRUE); res = gst_pad_event_default (pad, event); break; case GST_EVENT_TAG: { if (enc->tags) { GstTagList *list; gst_event_parse_tag (event, &list); gst_tag_list_insert (enc->tags, list, gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (enc))); } else { g_assert_not_reached (); } res = gst_pad_event_default (pad, event); break; } default: res = gst_pad_event_default (pad, event); break; } gst_object_unref (enc); return res; }
// GStreamer event filter that removes any image metadata. static gboolean remove_image(GstPad* pad, GstObject* parent, GstEvent* event) { GstTagList* tags = NULL; GstPad* sink = NULL; gboolean ret = false; switch (GST_EVENT_TYPE(event)) { case GST_EVENT_TAG: gst_event_parse_tag(event, &tags); gst_tag_list_remove_tag(tags, "image"); event = gst_event_new_tag(tags); break; case GST_EVENT_CAPS: sink = gst_element_get_static_pad(GST_ELEMENT(parent), "src"); ret = gst_pad_push_event(sink, event); gst_object_unref(sink); return ret; default: break; } return gst_pad_event_default(pad, parent, event); }
static gboolean gst_tag_lib_mux_sink_event (GstPad * pad, GstEvent * event) { GstTagLibMux *mux; gboolean result; mux = GST_TAG_LIB_MUX (gst_pad_get_parent (pad)); result = FALSE; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG:{ GstTagList *tags; gst_event_parse_tag (event, &tags); GST_INFO_OBJECT (mux, "Got tag event: %" GST_PTR_FORMAT, tags); if (mux->event_tags != NULL) { gst_tag_list_insert (mux->event_tags, tags, GST_TAG_MERGE_REPLACE); } else { mux->event_tags = gst_tag_list_copy (tags); } GST_INFO_OBJECT (mux, "Event tags are now: %" GST_PTR_FORMAT, mux->event_tags); /* just drop the event, we'll push a new tag event in render_tag */ gst_event_unref (event); result = TRUE; break; } case GST_EVENT_NEWSEGMENT:{ GstFormat fmt; gst_event_parse_new_segment (event, NULL, NULL, &fmt, NULL, NULL, NULL); if (fmt != GST_FORMAT_BYTES) { GST_WARNING_OBJECT (mux, "dropping newsegment event in %s format", gst_format_get_name (fmt)); gst_event_unref (event); break; } if (mux->render_tag) { /* we have not rendered the tag yet, which means that we don't know * how large it is going to be yet, so we can't adjust the offsets * here at this point and need to cache the newsegment event for now * (also, there could be tag events coming after this newsegment event * and before the first buffer). */ if (mux->newsegment_ev) { GST_WARNING_OBJECT (mux, "discarding old cached newsegment event"); gst_event_unref (mux->newsegment_ev); } GST_LOG_OBJECT (mux, "caching newsegment event for later"); mux->newsegment_ev = event; } else { GST_DEBUG_OBJECT (mux, "got newsegment event, adjusting offsets"); gst_pad_push_event (mux->srcpad, gst_tag_lib_mux_adjust_event_offsets (mux, event)); gst_event_unref (event); } event = NULL; result = TRUE; break; } default: result = gst_pad_event_default (pad, event); break; } gst_object_unref (mux); return result; }