GStreamer Plugin Writer's Guide (0.10.12) | ||
---|---|---|
<<< Previous | Next >>> |
Tags are pieces of information stored in a stream that are not the content itself, but they rather describe the content. Most media container formats support tagging in one way or another. Ogg uses VorbisComment for this, MP3 uses ID3, AVI and WAV use RIFF's INFO list chunk, etc. GStreamer provides a general way for elements to read tags from the stream and expose this to the user. The tags (at least the metadata) will be part of the stream inside the pipeline. The consequence of this is that transcoding of files from one format to another will automatically preserve tags, as long as the input and output format elements both support tagging.
Tags are separated in two categories in GStreamer, even though applications won't notice anything of this. The first are called metadata, the second are called streaminfo. Metadata are tags that describe the non-technical parts of stream content. They can be changed without needing to re-encode the stream completely. Examples are "author", "title" or "album". The container format might still need to be re-written for the tags to fit in, though. Streaminfo, on the other hand, are tags that describe the stream contents technically. To change them, the stream needs to be re-encoded. Examples are "codec" or "bitrate". Note that some container formats (like ID3) store various streaminfo tags as metadata in the file container, which means that they can be changed so that they don't match the content in the file anymore. Still, they are called metadata because technically, they can be changed without re-encoding the whole stream, even though that makes them invalid. Files with such metadata tags will have the same tag twice: once as metadata, once as streaminfo.
A tag reading element is called TagGetter
in
GStreamer.
A tag writer is called TagSetter
.
An element supporting both can be used in a tag editor for quick tag
changing.
The basic object for tags is a GstTagList
. An element that is reading tags from a stream should
create an empty taglist and fill this with individual tags. Empty tag
lists can be created with gst_tag_list_new (). Then,
the element can fill the list using gst_tag_list_add_values ()
. Note that an element probably reads metadata as strings, but
values might not necessarily be strings. Be sure to use
gst_value_transform ()
to make sure that your data is of the right type. After data reading, the
application can be notified of the new taglist by calling
gst_element_found_tags (). The tags should also be
part of the datastream, so they should be pushed over all source pads.
The function gst_event_new_tag () creates an event
from a taglist. This can be pushed over source pads using
gst_pad_push (). Simple elements with only one
source pad can combine all these steps all-in-one by using the function
gst_element_found_tags_for_pad ().
The following example program will parse a file and parse the data as metadata/tags rather than as actual content-data. It will parse each line as "name:value", where name is the type of metadata (title, author, ...) and value is the metadata value. The _getline () is the same as the one given in Sometimes pads.
static void gst_my_filter_loopfunc (GstElement *element) { GstMyFilter *filter = GST_MY_FILTER (element); GstBuffer *buf; GstTagList *taglist = gst_tag_list_new (); /* get each line and parse as metadata */ while ((buf = gst_my_filter_getline (filter))) { gchar *line = GST_BUFFER_DATA (buf), *colon_pos, *type = NULL;a /* get the position of the ':' and go beyond it */ if (!(colon_pos = strchr (line, ':'))) goto next: /* get the string before that as type of metadata */ type = g_strndup (line, colon_pos - line); /* content is one character beyond the ':' */ colon_pos = &colon_pos[1]; if (*colon_pos == '\0') goto next; /* get the metadata category, it's value type, store it in that * type and add it to the taglist. */ if (gst_tag_exists (type)) { GValue from = { 0 }, to = { 0 }; GType to_type; to_type = gst_tag_get_type (type); g_value_init (&from, G_TYPE_STRING); g_value_set_string (&from, colon_pos); g_value_init (&to, to_type); g_value_transform (&from, &to); g_value_unset (&from); gst_tag_list_add_values (taglist, GST_TAG_MERGE_APPEND, type, &to, NULL); g_value_unset (&to); } next: g_free (type); gst_buffer_unref (buf); } /* signal metadata */ gst_element_found_tags_for_pad (element, filter->srcpad, 0, taglist); gst_tag_list_free (taglist); /* send EOS */ gst_pad_send_event (filter->srcpad, GST_DATA (gst_event_new (GST_EVENT_EOS))); gst_element_set_eos (element); } |
We currently assume the core to already know the mimetype (gst_tag_exists ()). You can add new tags to the list of known tags using gst_tag_register (). If you think the tag will be useful in more cases than just your own element, it might be a good idea to add it to gsttag.c instead. That's up to you to decide. If you want to do it in your own element, it's easiest to register the tag in one of your class init functions, preferrably _class_init ().
static void gst_my_filter_class_init (GstMyFilterClass *klass) { [..] gst_tag_register ("my_tag_name", GST_TAG_FLAG_META, G_TYPE_STRING, _("my own tag"), _("a tag that is specific to my own element"), NULL); [..] } |
<<< Previous | Home | Next >>> |
Navigation Interface | Up | Writing Tags to Streams |