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_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 GstBuffer *
gst_speex_enc_create_metadata_buffer (GstSpeexEnc * enc)
{
const GstTagList *user_tags;
GstTagList *merged_tags;
GstBuffer *comments = NULL;
user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (enc));
GST_DEBUG_OBJECT (enc, "upstream tags = %" GST_PTR_FORMAT, enc->tags);
GST_DEBUG_OBJECT (enc, "user-set tags = %" GST_PTR_FORMAT, user_tags);
/* gst_tag_list_merge() will handle NULL for either or both lists fine */
merged_tags = gst_tag_list_merge (user_tags, enc->tags,
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (enc)));
if (merged_tags == NULL)
merged_tags = gst_tag_list_new ();
GST_DEBUG_OBJECT (enc, "merged tags = %" GST_PTR_FORMAT, merged_tags);
comments = gst_tag_list_to_vorbiscomment_buffer (merged_tags, NULL,
0, "Encoded with GStreamer Speexenc");
gst_tag_list_free (merged_tags);
GST_BUFFER_OFFSET (comments) = enc->bytes_out;
GST_BUFFER_OFFSET_END (comments) = 0;
return comments;
}
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
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_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 void
gst_shout2send_set_metadata (GstShout2send * shout2send)
{
const GstTagList *user_tags;
GstTagList *copy;
char *tempmetadata;
shout_metadata_t *pmetadata;
g_return_if_fail (shout2send != NULL);
user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (shout2send));
if ((shout2send->tags == NULL) && (user_tags == NULL)) {
return;
}
copy = gst_tag_list_merge (user_tags, shout2send->tags,
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (shout2send)));
/* lets get the artist and song tags */
tempmetadata = NULL;
gst_tag_list_foreach ((GstTagList *) copy, set_shout_metadata,
(gpointer) & tempmetadata);
if (tempmetadata) {
pmetadata = shout_metadata_new ();
shout_metadata_add (pmetadata, "song", tempmetadata);
shout_set_metadata (shout2send->conn, pmetadata);
shout_metadata_free (pmetadata);
}
gst_tag_list_unref (copy);
}
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
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_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_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 GstFlowReturn
gst_vorbis_tag_parse_packet (GstVorbisParse * parse, GstBuffer * buffer)
{
GstTagList *old_tags, *new_tags;
const GstTagList *user_tags;
GstVorbisTag *tagger;
gchar *encoder = NULL;
GstBuffer *new_buf;
GstMapInfo map;
gboolean do_parse = FALSE;
gst_buffer_map (buffer, &map, GST_MAP_READ);
/* just pass everything except the comments packet */
if (map.size >= 1 && map.data[0] != 0x03)
do_parse = TRUE;
gst_buffer_unmap (buffer, &map);
if (do_parse) {
return GST_VORBIS_PARSE_CLASS (parent_class)->parse_packet (parse, buffer);
}
tagger = GST_VORBIS_TAG (parse);
old_tags =
gst_tag_list_from_vorbiscomment_buffer (buffer, (guint8 *) "\003vorbis",
7, &encoder);
user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (tagger));
/* build new tag list */
new_tags = gst_tag_list_merge (user_tags, old_tags,
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (tagger)));
gst_tag_list_unref (old_tags);
new_buf =
gst_tag_list_to_vorbiscomment_buffer (new_tags, (guint8 *) "\003vorbis",
7, encoder);
gst_buffer_copy_into (new_buf, buffer, GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
gst_tag_list_unref (new_tags);
g_free (encoder);
gst_buffer_unref (buffer);
return GST_VORBIS_PARSE_CLASS (parent_class)->parse_packet (parse, new_buf);
}
static GstFlowReturn
gst_wavenc_write_tags (GstWavEnc * wavenc)
{
const GstTagList *user_tags;
GstTagList *tags;
guint size;
GstBuffer *buf;
GstByteWriter bw;
g_return_val_if_fail (wavenc != NULL, GST_FLOW_OK);
user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (wavenc));
if ((!wavenc->tags) && (!user_tags)) {
GST_DEBUG_OBJECT (wavenc, "have no tags");
return GST_FLOW_OK;
}
tags =
gst_tag_list_merge (user_tags, wavenc->tags,
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (wavenc)));
GST_DEBUG_OBJECT (wavenc, "writing tags");
gst_byte_writer_init_with_size (&bw, 1024, FALSE);
/* add LIST INFO chunk */
gst_byte_writer_put_data (&bw, (const guint8 *) "LIST", 4);
gst_byte_writer_put_uint32_le (&bw, 0);
gst_byte_writer_put_data (&bw, (const guint8 *) "INFO", 4);
/* add tags */
gst_tag_list_foreach (tags, gst_wavparse_tags_foreach, &bw);
/* sets real size of LIST INFO chunk */
size = gst_byte_writer_get_pos (&bw);
gst_byte_writer_set_pos (&bw, 4);
gst_byte_writer_put_uint32_le (&bw, size - 8);
gst_tag_list_unref (tags);
buf = gst_byte_writer_reset_and_get_buffer (&bw);
wavenc->meta_length += gst_buffer_get_size (buf);
return gst_pad_push (wavenc->srcpad, buf);
}
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 void
gst_kate_enc_set_metadata (GstKateEnc * ke)
{
GstTagList *merged_tags;
const GstTagList *user_tags;
user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (ke));
GST_DEBUG_OBJECT (ke, "upstream tags = %" GST_PTR_FORMAT, ke->tags);
GST_DEBUG_OBJECT (ke, "user-set tags = %" GST_PTR_FORMAT, user_tags);
/* gst_tag_list_merge() will handle NULL for either or both lists fine */
merged_tags = gst_tag_list_merge (user_tags, ke->tags,
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (ke)));
if (merged_tags) {
GST_DEBUG_OBJECT (ke, "merged tags = %" GST_PTR_FORMAT, merged_tags);
gst_tag_list_foreach (merged_tags, gst_kate_enc_metadata_set1, ke);
gst_tag_list_unref (merged_tags);
}
}
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 void
gst_vorbis_enc_set_metadata (GstVorbisEnc * enc)
{
GstTagList *merged_tags;
const GstTagList *user_tags;
vorbis_comment_init (&enc->vc);
user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (enc));
GST_DEBUG_OBJECT (enc, "upstream tags = %" GST_PTR_FORMAT, enc->tags);
GST_DEBUG_OBJECT (enc, "user-set tags = %" GST_PTR_FORMAT, user_tags);
/* gst_tag_list_merge() will handle NULL for either or both lists fine */
merged_tags = gst_tag_list_merge (user_tags, enc->tags,
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (enc)));
if (merged_tags) {
GST_DEBUG_OBJECT (enc, "merged tags = %" GST_PTR_FORMAT, merged_tags);
gst_tag_list_foreach (merged_tags, gst_vorbis_enc_metadata_set1, enc);
gst_tag_list_unref (merged_tags);
}
}
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;
}
static GstTagList *
gst_tag_mux_get_tags (GstTagMux * mux)
{
GstTagSetter *tagsetter = GST_TAG_SETTER (mux);
const GstTagList *tagsetter_tags;
GstTagMergeMode merge_mode;
if (mux->priv->final_tags)
return mux->priv->final_tags;
tagsetter_tags = gst_tag_setter_get_tag_list (tagsetter);
merge_mode = gst_tag_setter_get_tag_merge_mode (tagsetter);
GST_LOG_OBJECT (mux, "merging tags, merge mode = %d", merge_mode);
GST_LOG_OBJECT (mux, "event tags: %" GST_PTR_FORMAT, mux->priv->event_tags);
GST_LOG_OBJECT (mux, "set tags: %" GST_PTR_FORMAT, tagsetter_tags);
mux->priv->final_tags =
gst_tag_list_merge (tagsetter_tags, mux->priv->event_tags, merge_mode);
GST_LOG_OBJECT (mux, "final tags: %" GST_PTR_FORMAT, mux->priv->final_tags);
return mux->priv->final_tags;
}
static GstBuffer *
gst_tag_lib_mux_render_tag (GstTagLibMux * mux)
{
GstTagLibMuxClass *klass;
GstTagMergeMode merge_mode;
GstTagSetter *tagsetter;
GstBuffer *buffer;
const GstTagList *tagsetter_tags;
GstTagList *taglist;
GstEvent *event;
tagsetter = GST_TAG_SETTER (mux);
tagsetter_tags = gst_tag_setter_get_tag_list (tagsetter);
merge_mode = gst_tag_setter_get_tag_merge_mode (tagsetter);
GST_LOG_OBJECT (mux, "merging tags, merge mode = %d", merge_mode);
GST_LOG_OBJECT (mux, "event tags: %" GST_PTR_FORMAT, mux->event_tags);
GST_LOG_OBJECT (mux, "set tags: %" GST_PTR_FORMAT, tagsetter_tags);
taglist = gst_tag_list_merge (tagsetter_tags, mux->event_tags, merge_mode);
GST_LOG_OBJECT (mux, "final tags: %" GST_PTR_FORMAT, taglist);
klass = GST_TAG_LIB_MUX_CLASS (G_OBJECT_GET_CLASS (mux));
if (klass->render_tag == NULL)
goto no_vfunc;
buffer = klass->render_tag (mux, taglist);
if (buffer == NULL)
goto render_error;
mux->tag_size = GST_BUFFER_SIZE (buffer);
GST_LOG_OBJECT (mux, "tag size = %" G_GSIZE_FORMAT " bytes", mux->tag_size);
/* Send newsegment event from byte position 0, so the tag really gets
* written to the start of the file, independent of the upstream segment */
gst_pad_push_event (mux->srcpad,
gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES, 0, -1, 0));
/* Send an event about the new tags to downstream elements */
/* gst_event_new_tag takes ownership of the list, so no need to unref it */
event = gst_event_new_tag (taglist);
gst_pad_push_event (mux->srcpad, event);
GST_BUFFER_OFFSET (buffer) = 0;
return buffer;
no_vfunc:
{
GST_ERROR_OBJECT (mux, "Subclass does not implement render_tag vfunc!");
gst_tag_list_free (taglist);
return NULL;
}
render_error:
{
GST_ERROR_OBJECT (mux, "Failed to render tag");
gst_tag_list_free (taglist);
return NULL;
}
}
static gboolean
gst_kate_enc_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
GstKateEnc *ke = GST_KATE_ENC (parent);
const GstStructure *structure;
gboolean ret;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CAPS:
{
GstCaps *caps;
gst_event_parse_caps (event, &caps);
ret = gst_kate_enc_setcaps (ke, caps);
gst_event_unref (event);
break;
}
case GST_EVENT_SEGMENT:{
GstSegment seg;
GST_LOG_OBJECT (ke, "Got newsegment event");
gst_event_copy_segment (event, &seg);
if (!ke->headers_sent) {
if (ke->pending_segment)
gst_event_unref (ke->pending_segment);
ke->pending_segment = event;
event = NULL;
}
if (ke->initialized) {
GST_LOG_OBJECT (ke, "ensuring all headers are in");
if (gst_kate_enc_flush_headers (ke) != GST_FLOW_OK) {
GST_WARNING_OBJECT (ke, "Failed to flush headers");
} else {
if (seg.format != GST_FORMAT_TIME
|| !GST_CLOCK_TIME_IS_VALID (seg.start)) {
GST_WARNING_OBJECT (ke,
"No time in newsegment event %p, format %d, timestamp %"
G_GINT64_FORMAT, event, (int) seg.format, seg.start);
/* to be safe, we'd need to generate a keepalive anyway, but we'd have to guess at the timestamp to use; a
good guess would be the last known timestamp plus the keepalive time, but if we then get a packet with a
timestamp less than this, it would fail to encode, which would be Bad. If we don't encode a keepalive, we
run the risk of stalling the pipeline and hanging, which is Very Bad. Oh dear. We can't exit(-1), can we ? */
} else {
float t = seg.start / (double) GST_SECOND;
if (ke->delayed_spu
&& t - ke->delayed_start / (double) GST_SECOND >=
ke->default_spu_duration) {
if (G_UNLIKELY (gst_kate_enc_flush_waiting (ke,
seg.start) != GST_FLOW_OK)) {
GST_WARNING_OBJECT (ke, "Failed to encode delayed packet");
/* continue with new segment handling anyway */
}
}
GST_LOG_OBJECT (ke, "ts %f, last %f (min %f)", t,
ke->last_timestamp / (double) GST_SECOND,
ke->keepalive_min_time);
if (ke->keepalive_min_time > 0.0f
&& t - ke->last_timestamp / (double) GST_SECOND >=
ke->keepalive_min_time) {
/* we only generate a keepalive if there is no SPU waiting, as it would
mean out of sequence start times - and granulepos */
if (!ke->delayed_spu) {
gst_kate_enc_generate_keepalive (ke, seg.start);
}
}
}
}
}
if (event)
ret = gst_pad_push_event (ke->srcpad, event);
else
ret = TRUE;
break;
}
case GST_EVENT_CUSTOM_DOWNSTREAM:
GST_LOG_OBJECT (ke, "Got custom downstream event");
/* adapted from the dvdsubdec element */
structure = gst_event_get_structure (event);
if (structure != NULL
&& gst_structure_has_name (structure, "application/x-gst-dvd")) {
if (ke->initialized) {
GST_LOG_OBJECT (ke, "ensuring all headers are in");
if (gst_kate_enc_flush_headers (ke) != GST_FLOW_OK) {
GST_WARNING_OBJECT (ke, "Failed to flush headers");
} else {
const gchar *event_name =
gst_structure_get_string (structure, "event");
if (event_name) {
if (!strcmp (event_name, "dvd-spu-clut-change")) {
gchar name[16];
int idx;
gboolean found;
gint value;
GST_INFO_OBJECT (ke, "New CLUT received");
for (idx = 0; idx < 16; ++idx) {
g_snprintf (name, sizeof (name), "clut%02d", idx);
found = gst_structure_get_int (structure, name, &value);
if (found) {
ke->spu_clut[idx] = value;
} else {
GST_WARNING_OBJECT (ke,
"DVD CLUT event did not contain %s field", name);
}
}
} else if (!strcmp (event_name, "dvd-lang-codes")) {
/* we can't know which stream corresponds to us */
}
} else {
GST_WARNING_OBJECT (ke, "custom downstream event with no name");
}
}
}
}
ret = gst_pad_push_event (ke->srcpad, event);
break;
case GST_EVENT_TAG:
GST_LOG_OBJECT (ke, "Got tag event");
if (ke->tags) {
GstTagList *list;
gst_event_parse_tag (event, &list);
gst_tag_list_insert (ke->tags, list,
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (ke)));
} else {
g_assert_not_reached ();
}
ret = gst_pad_event_default (pad, parent, event);
break;
case GST_EVENT_EOS:
GST_INFO_OBJECT (ke, "Got EOS event");
if (ke->initialized) {
GST_LOG_OBJECT (ke, "ensuring all headers are in");
if (gst_kate_enc_flush_headers (ke) != GST_FLOW_OK) {
GST_WARNING_OBJECT (ke, "Failed to flush headers");
} else {
kate_packet kp;
int ret;
GstClockTime delayed_end =
ke->delayed_start + ke->default_spu_duration * GST_SECOND;
if (G_UNLIKELY (gst_kate_enc_flush_waiting (ke,
delayed_end) != GST_FLOW_OK)) {
GST_WARNING_OBJECT (ke, "Failed to encode delayed packet");
/* continue with EOS handling anyway */
}
ret = kate_encode_finish (&ke->k, -1, &kp);
if (ret < 0) {
GST_WARNING_OBJECT (ke, "Failed to encode EOS packet: %s",
gst_kate_util_get_error_message (ret));
} else {
kate_int64_t granpos = kate_encode_get_granule (&ke->k);
GST_LOG_OBJECT (ke, "EOS packet encoded");
if (gst_kate_enc_push_and_free_kate_packet (ke, &kp, granpos,
ke->latest_end_time, 0, FALSE)) {
GST_WARNING_OBJECT (ke, "Failed to push EOS packet");
}
}
}
}
ret = gst_pad_event_default (pad, parent, event);
break;
default:
GST_LOG_OBJECT (ke, "Got unhandled event");
ret = gst_pad_event_default (pad, parent, event);
break;
}
return ret;
}
static GstFlowReturn
gst_flac_tag_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
GstFlacTag *tag;
GstFlowReturn ret;
GstMapInfo map;
gsize size;
ret = GST_FLOW_OK;
tag = GST_FLAC_TAG (parent);
gst_adapter_push (tag->adapter, buffer);
/* Initial state, we don't even know if we are dealing with a flac file */
if (tag->state == GST_FLAC_TAG_STATE_INIT) {
GstBuffer *id_buffer;
if (gst_adapter_available (tag->adapter) < sizeof (FLAC_MAGIC))
goto cleanup;
id_buffer = gst_adapter_take_buffer (tag->adapter, FLAC_MAGIC_SIZE);
GST_DEBUG_OBJECT (tag, "looking for " FLAC_MAGIC " identifier");
if (gst_buffer_memcmp (id_buffer, 0, FLAC_MAGIC, FLAC_MAGIC_SIZE) == 0) {
GST_DEBUG_OBJECT (tag, "pushing " FLAC_MAGIC " identifier buffer");
ret = gst_pad_push (tag->srcpad, id_buffer);
if (ret != GST_FLOW_OK)
goto cleanup;
tag->state = GST_FLAC_TAG_STATE_METADATA_BLOCKS;
} else {
/* FIXME: does that work well with FLAC files containing ID3v2 tags ? */
gst_buffer_unref (id_buffer);
GST_ELEMENT_ERROR (tag, STREAM, WRONG_TYPE, (NULL), (NULL));
ret = GST_FLOW_ERROR;
}
}
/* The fLaC magic string has been skipped, try to detect the beginning
* of a metadata block
*/
if (tag->state == GST_FLAC_TAG_STATE_METADATA_BLOCKS) {
guint type;
gboolean is_last;
const guint8 *block_header;
g_assert (tag->metadata_block_size == 0);
g_assert (tag->metadata_last_block == FALSE);
/* The header of a flac metadata block is 4 bytes long:
* 1st bit: indicates whether this is the last metadata info block
* 7 next bits: 4 if vorbis comment block
* 24 next bits: size of the metadata to follow (big endian)
*/
if (gst_adapter_available (tag->adapter) < 4)
goto cleanup;
block_header = gst_adapter_map (tag->adapter, 4);
is_last = ((block_header[0] & 0x80) == 0x80);
type = block_header[0] & 0x7F;
size = (block_header[1] << 16)
| (block_header[2] << 8)
| block_header[3];
gst_adapter_unmap (tag->adapter);
/* The 4 bytes long header isn't included in the metadata size */
tag->metadata_block_size = size + 4;
tag->metadata_last_block = is_last;
GST_DEBUG_OBJECT (tag,
"got metadata block: %" G_GSIZE_FORMAT " bytes, type %d, "
"is vorbiscomment: %d, is last: %d",
size, type, (type == 0x04), is_last);
/* Metadata blocks of type 4 are vorbis comment blocks */
if (type == 0x04) {
tag->state = GST_FLAC_TAG_STATE_VC_METADATA_BLOCK;
} else {
tag->state = GST_FLAC_TAG_STATE_WRITING_METADATA_BLOCK;
}
}
/* Reads a metadata block */
if ((tag->state == GST_FLAC_TAG_STATE_WRITING_METADATA_BLOCK) ||
(tag->state == GST_FLAC_TAG_STATE_VC_METADATA_BLOCK)) {
GstBuffer *metadata_buffer;
if (gst_adapter_available (tag->adapter) < tag->metadata_block_size)
goto cleanup;
metadata_buffer = gst_adapter_take_buffer (tag->adapter,
tag->metadata_block_size);
/* clear the is-last flag, as the last metadata block will
* be the vorbis comment block which we will build ourselves.
*/
gst_buffer_map (metadata_buffer, &map, GST_MAP_READWRITE);
map.data[0] &= (~0x80);
gst_buffer_unmap (metadata_buffer, &map);
if (tag->state == GST_FLAC_TAG_STATE_WRITING_METADATA_BLOCK) {
GST_DEBUG_OBJECT (tag, "pushing metadata block buffer");
ret = gst_pad_push (tag->srcpad, metadata_buffer);
if (ret != GST_FLOW_OK)
goto cleanup;
} else {
tag->vorbiscomment = metadata_buffer;
}
tag->metadata_block_size = 0;
tag->state = GST_FLAC_TAG_STATE_METADATA_NEXT_BLOCK;
}
/* This state is mainly used to be able to stop as soon as we read
* a vorbiscomment block from the flac file if we are in an only output
* tags mode
*/
if (tag->state == GST_FLAC_TAG_STATE_METADATA_NEXT_BLOCK) {
/* Check if in the previous iteration we read a vorbis comment metadata
* block, and stop now if the user only wants to read tags
*/
if (tag->vorbiscomment != NULL) {
guint8 id_data[4];
/* We found some tags, try to parse them and notify the other elements
* that we encountered some tags
*/
GST_DEBUG_OBJECT (tag, "emitting vorbiscomment tags");
gst_buffer_extract (tag->vorbiscomment, 0, id_data, 4);
tag->tags = gst_tag_list_from_vorbiscomment_buffer (tag->vorbiscomment,
id_data, 4, NULL);
if (tag->tags != NULL) {
gst_pad_push_event (tag->srcpad,
gst_event_new_tag (gst_tag_list_copy (tag->tags)));
}
gst_buffer_unref (tag->vorbiscomment);
tag->vorbiscomment = NULL;
}
/* Skip to next state */
if (tag->metadata_last_block == FALSE) {
tag->state = GST_FLAC_TAG_STATE_METADATA_BLOCKS;
} else {
tag->state = GST_FLAC_TAG_STATE_ADD_VORBIS_COMMENT;
}
}
/* Creates a vorbis comment block from the metadata which was set
* on the gstreamer element, and add it to the flac stream
*/
if (tag->state == GST_FLAC_TAG_STATE_ADD_VORBIS_COMMENT) {
GstBuffer *buffer;
const GstTagList *user_tags;
GstTagList *merged_tags;
/* merge the tag lists */
user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (tag));
if (user_tags != NULL) {
merged_tags = gst_tag_list_merge (user_tags, tag->tags,
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (tag)));
} else {
merged_tags = gst_tag_list_copy (tag->tags);
}
if (merged_tags == NULL) {
/* If we get a NULL list of tags, we must generate a padding block
* which is marked as the last metadata block, otherwise we'll
* end up with a corrupted flac file.
*/
GST_WARNING_OBJECT (tag, "No tags found");
buffer = gst_buffer_new_and_alloc (12);
if (buffer == NULL)
goto no_buffer;
gst_buffer_map (buffer, &map, GST_MAP_WRITE);
memset (map.data, 0, map.size);
map.data[0] = 0x81; /* 0x80 = Last metadata block,
* 0x01 = padding block */
gst_buffer_unmap (buffer, &map);
} else {
guchar header[4];
guint8 fbit[1];
memset (header, 0, sizeof (header));
header[0] = 0x84; /* 0x80 = Last metadata block,
* 0x04 = vorbiscomment block */
buffer = gst_tag_list_to_vorbiscomment_buffer (merged_tags, header,
sizeof (header), NULL);
GST_DEBUG_OBJECT (tag, "Writing tags %" GST_PTR_FORMAT, merged_tags);
gst_tag_list_free (merged_tags);
if (buffer == NULL)
goto no_comment;
size = gst_buffer_get_size (buffer);
if ((size < 4) || ((size - 4) > 0xFFFFFF))
goto comment_too_long;
fbit[0] = 1;
/* Get rid of the framing bit at the end of the vorbiscomment buffer
* if it exists since libFLAC seems to lose sync because of this
* bit in gstflacdec
*/
if (gst_buffer_memcmp (buffer, size - 1, fbit, 1) == 0) {
buffer = gst_buffer_make_writable (buffer);
gst_buffer_resize (buffer, 0, size - 1);
}
}
/* The 4 byte metadata block header isn't accounted for in the total
* size of the metadata block
*/
gst_buffer_map (buffer, &map, GST_MAP_WRITE);
map.data[1] = (((map.size - 4) & 0xFF0000) >> 16);
map.data[2] = (((map.size - 4) & 0x00FF00) >> 8);
map.data[3] = ((map.size - 4) & 0x0000FF);
gst_buffer_unmap (buffer, &map);
GST_DEBUG_OBJECT (tag, "pushing %" G_GSIZE_FORMAT " byte vorbiscomment "
"buffer", map.size);
ret = gst_pad_push (tag->srcpad, buffer);
if (ret != GST_FLOW_OK) {
goto cleanup;
}
tag->state = GST_FLAC_TAG_STATE_AUDIO_DATA;
}
