GST_END_TEST
GST_START_TEST (test_date_tags)
{
GstTagList *tag_list, *tag_list2;
GDate *date, *date2;
gchar *str;
date = g_date_new_dmy (14, 10, 2005);
tag_list = gst_tag_list_new_empty ();
gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND, GST_TAG_DATE, date, NULL);
str = gst_tag_list_to_string (tag_list);
fail_if (str == NULL);
fail_if (strstr (str, "2005-10-14") == NULL);
tag_list2 = gst_tag_list_new_from_string (str);
fail_if (tag_list2 == NULL);
fail_if (!gst_tag_list_get_date (tag_list2, GST_TAG_DATE, &date2));
fail_unless (gst_tag_list_is_equal (tag_list2, tag_list));
gst_tag_list_unref (tag_list2);
g_free (str);
fail_if (g_date_compare (date, date2) != 0);
fail_if (g_date_get_day (date) != 14);
fail_if (g_date_get_month (date) != 10);
fail_if (g_date_get_year (date) != 2005);
fail_if (g_date_get_day (date2) != 14);
fail_if (g_date_get_month (date2) != 10);
fail_if (g_date_get_year (date2) != 2005);
g_date_free (date2);
gst_tag_list_unref (tag_list);
g_date_free (date);
}
GST_END_TEST
GST_START_TEST (test_merge_modes)
{
GstTagMergeMode mode;
for (mode = GST_TAG_MERGE_REPLACE_ALL; mode < GST_TAG_MERGE_COUNT; mode++) {
gint i;
for (i = 0; i < 4; i++) {
GstElement *enc;
GstTagSetter *setter;
GstTagList *list1, *list2, *merged;
enc = g_object_new (GST_TYPE_DUMMY_ENC, NULL);
fail_unless (enc != NULL);
setter = GST_TAG_SETTER (enc);
list1 = gst_tag_list_new_empty ();
list2 = gst_tag_list_new_empty ();
/* i = 0: - -
* i = 1: list1 -
* i = 2: - list2
* i = 3: list1 list2 */
if (i % 2 == 1) {
gst_tag_list_add (list1, GST_TAG_MERGE_APPEND, GST_TAG_ARTIST,
"artist1", NULL);
}
if (i > 1) {
gst_tag_list_add (list2, GST_TAG_MERGE_APPEND, GST_TAG_ARTIST,
"artist2", NULL);
}
gst_tag_setter_merge_tags (setter, list1, GST_TAG_MERGE_APPEND);
gst_tag_setter_merge_tags (setter, list2, mode);
merged = gst_tag_list_merge (list1, list2, mode);
fail_unless_equals_int (tag_list_length (gst_tag_setter_get_tag_list
(setter)), tag_list_length (merged));
gst_tag_list_unref (list1);
gst_tag_list_unref (list2);
gst_tag_list_unref (merged);
gst_object_unref (enc);
}
}
}
static void
set_language (AurClient * client)
{
gint num_audio, cur_audio, i;
g_object_get (client->player, "n-audio", &num_audio, "current-audio",
&cur_audio, NULL);
for (i = 0; i < num_audio; i++) {
GstTagList *tags;
gchar *str = NULL;
gboolean found = FALSE;
g_signal_emit_by_name (client->player, "get-audio-tags", i, &tags);
if (!tags)
continue;
if (gst_tag_list_get_string (tags, GST_TAG_LANGUAGE_CODE, &str))
found = g_str_equal (client->language, str);
gst_tag_list_unref (tags);
g_free (str);
if (found) {
g_object_set (client->player, "current-audio", i, NULL);
break;
}
}
}
static GstBuffer *
gst_celt_enc_create_metadata_buffer (GstCeltEnc * enc)
{
const GstTagList *tags;
GstTagList *empty_tags = NULL;
GstBuffer *comments = NULL;
tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (enc));
GST_DEBUG_OBJECT (enc, "tags = %" GST_PTR_FORMAT, tags);
if (tags == NULL) {
/* FIXME: better fix chain of callers to not write metadata at all,
* if there is none */
empty_tags = gst_tag_list_new_empty ();
tags = empty_tags;
}
comments = gst_tag_list_to_vorbiscomment_buffer (tags, NULL,
0, "Encoded with GStreamer Celtenc");
GST_BUFFER_OFFSET (comments) = 0;
GST_BUFFER_OFFSET_END (comments) = 0;
if (empty_tags)
gst_tag_list_unref (empty_tags);
return comments;
}
/**
* gst_toc_copy:
* @toc: #GstToc to copy.
*
* Copy #GstToc with all subentries (deep copy).
*
* Returns: newly allocated #GstToc in case of success, NULL otherwise;
* free it when done with gst_toc_unref().
*/
static GstToc *
gst_toc_copy (const GstToc * toc)
{
GstToc *ret;
GstTocEntry *entry;
GList *cur;
GstTagList *list;
g_return_val_if_fail (toc != NULL, NULL);
ret = gst_toc_new (toc->scope);
if (GST_IS_TAG_LIST (toc->tags)) {
list = gst_tag_list_copy (toc->tags);
gst_tag_list_unref (ret->tags);
ret->tags = list;
}
cur = toc->entries;
while (cur != NULL) {
entry = gst_toc_entry_copy (cur->data);
if (entry != NULL)
ret->entries = g_list_prepend (ret->entries, entry);
cur = cur->next;
}
ret->entries = g_list_reverse (ret->entries);
return ret;
}
static GstFlowReturn
gst_dirac_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
{
GstDiracParse *diracparse = GST_DIRAC_PARSE (parse);
if (!diracparse->sent_codec_tag) {
GstTagList *taglist;
GstCaps *caps;
taglist = gst_tag_list_new_empty ();
/* codec tag */
caps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (parse));
gst_pb_utils_add_codec_description_to_tag_list (taglist,
GST_TAG_VIDEO_CODEC, caps);
gst_caps_unref (caps);
gst_base_parse_merge_tags (parse, taglist, GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (taglist);
/* also signals the end of first-frame processing */
diracparse->sent_codec_tag = TRUE;
}
return GST_FLOW_OK;
}
static GstFlowReturn
gst_png_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
{
GstPngParse *pngparse = GST_PNG_PARSE (parse);
if (!pngparse->sent_codec_tag) {
GstTagList *taglist;
GstCaps *caps;
/* codec tag */
caps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (parse));
if (G_UNLIKELY (caps == NULL)) {
if (GST_PAD_IS_FLUSHING (GST_BASE_PARSE_SRC_PAD (parse))) {
GST_INFO_OBJECT (parse, "Src pad is flushing");
return GST_FLOW_FLUSHING;
} else {
GST_INFO_OBJECT (parse, "Src pad is not negotiated!");
return GST_FLOW_NOT_NEGOTIATED;
}
}
taglist = gst_tag_list_new_empty ();
gst_pb_utils_add_codec_description_to_tag_list (taglist,
GST_TAG_VIDEO_CODEC, caps);
gst_caps_unref (caps);
gst_base_parse_merge_tags (parse, taglist, GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (taglist);
/* also signals the end of first-frame processing */
pngparse->sent_codec_tag = TRUE;
}
return GST_FLOW_OK;
}
/**
* gst_toc_entry_copy:
* @entry: #GstTocEntry to copy.
*
* Copy #GstTocEntry with all subentries (deep copy).
*
* Returns: newly allocated #GstTocEntry in case of success, NULL otherwise;
* free it when done with gst_toc_entry_unref().
*/
static GstTocEntry *
gst_toc_entry_copy (const GstTocEntry * entry)
{
GstTocEntry *ret, *sub;
GstTagList *list;
GList *cur;
g_return_val_if_fail (entry != NULL, NULL);
ret = gst_toc_entry_new (entry->type, entry->uid);
ret->start = entry->start;
ret->stop = entry->stop;
if (GST_IS_TAG_LIST (entry->tags)) {
list = gst_tag_list_copy (entry->tags);
if (ret->tags)
gst_tag_list_unref (ret->tags);
ret->tags = list;
}
cur = entry->subentries;
while (cur != NULL) {
sub = gst_toc_entry_copy (cur->data);
if (sub != NULL)
ret->subentries = g_list_prepend (ret->subentries, sub);
cur = cur->next;
}
ret->subentries = g_list_reverse (ret->subentries);
return ret;
}
/* gst_x265_enc_set_src_caps
* Returns: TRUE on success.
*/
static gboolean
gst_x265_enc_set_src_caps (GstX265Enc * encoder, GstCaps * caps)
{
GstCaps *outcaps;
GstStructure *structure;
GstVideoCodecState *state;
GstTagList *tags;
outcaps = gst_caps_new_empty_simple ("video/x-h265");
structure = gst_caps_get_structure (outcaps, 0);
gst_structure_set (structure, "stream-format", G_TYPE_STRING, "byte-stream",
NULL);
gst_structure_set (structure, "alignment", G_TYPE_STRING, "au", NULL);
if (!gst_x265_enc_set_level_tier_and_profile (encoder, outcaps)) {
gst_caps_unref (outcaps);
return FALSE;
}
state = gst_video_encoder_set_output_state (GST_VIDEO_ENCODER (encoder),
outcaps, encoder->input_state);
GST_DEBUG_OBJECT (encoder, "output caps: %" GST_PTR_FORMAT, state->caps);
gst_video_codec_state_unref (state);
tags = gst_tag_list_new_empty ();
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_ENCODER, "x265",
GST_TAG_ENCODER_VERSION, x265_version_str, NULL);
gst_video_encoder_merge_tags (GST_VIDEO_ENCODER (encoder), tags,
GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (tags);
return TRUE;
}
static void
reset_extractor_data (MetadataExtractor *extractor)
{
if (extractor->tagcache != NULL) {
gst_tag_list_unref (extractor->tagcache);
extractor->tagcache = NULL;
}
g_free (extractor->audio_codec);
extractor->audio_codec = NULL;
g_free (extractor->video_codec);
extractor->video_codec = NULL;
extractor->has_audio = FALSE;
extractor->has_video = FALSE;
extractor->video_fps_n = -1;
extractor->video_fps_d = -1;
extractor->video_height = -1;
extractor->video_width = -1;
extractor->video_bitrate = -1;
extractor->audio_channels = -1;
extractor->audio_samplerate = -1;
extractor->audio_bitrate = -1;
}
/* This function is called when a "tag" message is posted on the bus. */
static void tag_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_TAG) {
GstTagList *tags = NULL;
gchar *title, *artist, *tagstring;
gst_message_parse_tag (msg, &tags);
get_tag (tags, GST_TAG_TITLE, &title);
get_tag (tags, GST_TAG_ARTIST, &artist);
g_print ("Title: %s Artist %s\n", title, artist);
tagstring = g_strdup_printf("%s - %s", title, artist);
/* only update when we got a meaningful tag */
if (!(0 == g_strcmp0 (title, "Unknown") &&
0 == g_strcmp0 (artist, "Unknown"))) {
update_taglabel(data, tagstring);
}
g_free(title);
g_free(artist);
g_free(tagstring);
#if GST_VERSION_MAJOR == (0)
gst_tag_list_free (tags);
#else
gst_tag_list_unref (tags);
#endif
}
}
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_empty ();
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_unref (merged_tags);
GST_BUFFER_OFFSET (comments) = 0;
GST_BUFFER_OFFSET_END (comments) = 0;
return comments;
}
static GstFlowReturn
daala_handle_comment_packet (GstDaalaDec * dec, ogg_packet * packet)
{
gchar *encoder = NULL;
GstTagList *list;
GST_DEBUG_OBJECT (dec, "parsing comment packet");
list =
gst_tag_list_from_vorbiscomment (packet->packet, packet->bytes,
(guint8 *) "\201daala", 6, &encoder);
if (!list) {
GST_ERROR_OBJECT (dec, "couldn't decode comments");
list = gst_tag_list_new_empty ();
}
if (encoder) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_ENCODER, encoder, NULL);
g_free (encoder);
}
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_ENCODER_VERSION, dec->info.version_major,
GST_TAG_VIDEO_CODEC, "Daala", NULL);
gst_video_decoder_merge_tags (GST_VIDEO_DECODER (dec),
list, GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (list);
return GST_FLOW_OK;
}
/* FIXME 0.11: remove tag handling and let container take care of that? */
static GstFlowReturn
vorbis_handle_comment_packet (GstVorbisDec * vd, ogg_packet * packet)
{
guint bitrate = 0;
gchar *encoder = NULL;
GstTagList *list;
guint8 *data;
gsize size;
GST_DEBUG_OBJECT (vd, "parsing comment packet");
data = gst_ogg_packet_data (packet);
size = gst_ogg_packet_size (packet);
list =
gst_tag_list_from_vorbiscomment (data, size, (guint8 *) "\003vorbis", 7,
&encoder);
if (!list) {
GST_ERROR_OBJECT (vd, "couldn't decode comments");
list = gst_tag_list_new_empty ();
}
if (encoder) {
if (encoder[0])
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_ENCODER, encoder, NULL);
g_free (encoder);
}
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_ENCODER_VERSION, vd->vi.version,
GST_TAG_AUDIO_CODEC, "Vorbis", NULL);
if (vd->vi.bitrate_nominal > 0 && vd->vi.bitrate_nominal <= 0x7FFFFFFF) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_NOMINAL_BITRATE, (guint) vd->vi.bitrate_nominal, NULL);
bitrate = vd->vi.bitrate_nominal;
}
if (vd->vi.bitrate_upper > 0 && vd->vi.bitrate_upper <= 0x7FFFFFFF) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_MAXIMUM_BITRATE, (guint) vd->vi.bitrate_upper, NULL);
if (!bitrate)
bitrate = vd->vi.bitrate_upper;
}
if (vd->vi.bitrate_lower > 0 && vd->vi.bitrate_lower <= 0x7FFFFFFF) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_MINIMUM_BITRATE, (guint) vd->vi.bitrate_lower, NULL);
if (!bitrate)
bitrate = vd->vi.bitrate_lower;
}
if (bitrate) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_BITRATE, (guint) bitrate, NULL);
}
gst_audio_decoder_merge_tags (GST_AUDIO_DECODER_CAST (vd), list,
GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (list);
return GST_FLOW_OK;
}
static void
check_cover_for_stream (ThumbApp *app,
const char *signal_name)
{
GdkPixbuf *pixbuf;
GstTagList *tags = NULL;
g_signal_emit_by_name (G_OBJECT (app->play), signal_name, 0, &tags);
if (!tags)
return;
pixbuf = xplayer_gst_tag_list_get_cover (tags);
if (!pixbuf) {
gst_tag_list_unref (tags);
return;
}
PROGRESS_DEBUG("Saving cover image");
thumb_app_cleanup (app);
save_pixbuf (pixbuf, app->output, app->input, output_size, TRUE);
g_object_unref (pixbuf);
exit (0);
}
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 void
gst_player_media_info_finalize (GObject * object)
{
GstPlayerMediaInfo *info = GST_PLAYER_MEDIA_INFO (object);
g_free (info->uri);
if (info->tags)
gst_tag_list_unref (info->tags);
g_free (info->title);
g_free (info->container);
if (info->image_sample)
gst_sample_unref (info->image_sample);
if (info->audio_stream_list)
g_list_free (info->audio_stream_list);
if (info->video_stream_list)
g_list_free (info->video_stream_list);
if (info->subtitle_stream_list)
g_list_free (info->subtitle_stream_list);
if (info->stream_list)
g_list_free_full (info->stream_list, g_object_unref);
G_OBJECT_CLASS (gst_player_media_info_parent_class)->finalize (object);
}
static inline void
extract_and_queue_tags (GstJpegParse * parse, guint size, guint8 * data,
GstTagList * (*tag_func) (GstBuffer * buff))
{
GstTagList *tags;
GstBuffer *buf;
buf = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY, data, size, 0,
size, NULL, NULL);
tags = tag_func (buf);
gst_buffer_unref (buf);
if (tags) {
GstTagList *taglist = parse->priv->tags;
if (taglist) {
gst_tag_list_insert (taglist, tags, GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (tags);
} else {
parse->priv->tags = tags;
}
GST_DEBUG_OBJECT (parse, "collected tags: %" GST_PTR_FORMAT,
parse->priv->tags);
}
}
static GstBuffer *
gst_opus_enc_create_metadata_buffer (const GstTagList * tags)
{
GstTagList *empty_tags = NULL;
GstBuffer *comments = NULL;
GST_DEBUG ("tags = %" GST_PTR_FORMAT, tags);
if (tags == NULL) {
/* FIXME: better fix chain of callers to not write metadata at all,
* if there is none */
empty_tags = gst_tag_list_new_empty ();
tags = empty_tags;
}
comments =
gst_tag_list_to_vorbiscomment_buffer (tags, (const guint8 *) "OpusTags",
8, "Encoded with GStreamer Opusenc");
GST_BUFFER_OFFSET (comments) = 0;
GST_BUFFER_OFFSET_END (comments) = 0;
if (empty_tags)
gst_tag_list_unref (empty_tags);
return comments;
}
static gboolean
bus_handler (GstBus * bus, GstMessage * message, gpointer data)
{
GMainLoop *loop = (GMainLoop *) data;
switch (message->type) {
case GST_MESSAGE_EOS:
g_main_loop_quit (loop);
break;
case GST_MESSAGE_WARNING:
case GST_MESSAGE_ERROR:{
GError *gerror;
gchar *debug;
gst_message_parse_error (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
g_error_free (gerror);
g_free (debug);
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_TAG:{
if (received_tags == NULL) {
gst_message_parse_tag (message, &received_tags);
} else {
GstTagList *tl = NULL, *ntl = NULL;
gst_message_parse_tag (message, &tl);
if (tl) {
ntl = gst_tag_list_merge (received_tags, tl, GST_TAG_MERGE_PREPEND);
if (ntl) {
GST_LOG ("taglists merged: %" GST_PTR_FORMAT, ntl);
gst_tag_list_unref (received_tags);
received_tags = ntl;
}
gst_tag_list_unref (tl);
}
}
break;
}
default:
break;
}
return TRUE;
}
static void
play_cycle_track_selection (GstPlay * play, GstPlayTrackType track_type)
{
const gchar *prop_cur, *prop_n, *prop_get, *name;
gint cur = -1, n = -1;
switch (track_type) {
case GST_PLAY_TRACK_TYPE_AUDIO:
prop_get = "get-audio-tags";
prop_cur = "current-audio";
prop_n = "n-audio";
name = "audio";
break;
case GST_PLAY_TRACK_TYPE_VIDEO:
prop_get = "get-video-tags";
prop_cur = "current-video";
prop_n = "n-video";
name = "video";
break;
case GST_PLAY_TRACK_TYPE_SUBTITLE:
prop_get = "get-text-tags";
prop_cur = "current-text";
prop_n = "n-text";
name = "subtitle";
break;
default:
return;
}
g_object_get (play->playbin, prop_cur, &cur, prop_n, &n, NULL);
if (n < 1) {
g_print ("No %s tracks.\n", name);
} else if (n == 1) {
g_print ("No other %s tracks to switch to.\n", name);
} else {
gchar *lcode = NULL, *lname = NULL;
const gchar *lang = NULL;
GstTagList *tags = NULL;
cur = (cur + 1) % n;
g_signal_emit_by_name (play->playbin, prop_get, cur, &tags);
if (tags != NULL) {
if (gst_tag_list_get_string (tags, GST_TAG_LANGUAGE_CODE, &lcode))
lang = gst_tag_get_language_name (lcode);
else if (gst_tag_list_get_string (tags, GST_TAG_LANGUAGE_NAME, &lname))
lang = lname;
gst_tag_list_unref (tags);
}
if (lang != NULL)
g_print ("Switching to %s track %d of %d (%s).\n", name, cur + 1, n,
lang);
else
g_print ("Switching to %s track %d of %d.\n", name, cur + 1, n);
g_object_set (play->playbin, prop_cur, cur, NULL);
g_free (lcode);
g_free (lname);
}
}
void
gst_kate_util_decoder_base_add_tags (GstKateDecoderBase * decoder,
GstTagList * tags, gboolean take_ownership_of_tags)
{
if (!decoder->tags) {
if (!take_ownership_of_tags)
tags = gst_tag_list_ref (tags);
decoder->tags = tags;
} else {
GstTagList *old = decoder->tags;
decoder->tags = gst_tag_list_merge (old, tags, GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (old);
if (take_ownership_of_tags)
gst_tag_list_unref (tags);
}
decoder->tags_changed = TRUE;
}
void tag_cb(GstBus *bus, GstMessage *msg, CustomData *data)
{
GstTagList *tags = NULL;
gst_message_parse_tag(msg, &tags);
GPlayerDEBUG("Got tags from element %s:\n", GST_OBJECT_NAME(msg->src));
gst_tag_list_foreach(tags, (GstTagForeachFunc) print_one_tag, data);
gst_tag_list_unref(tags);
gst_message_unref(msg);
}
CAMLprim value ocaml_gstreamer_message_parse_tag(value _msg)
{
CAMLparam1(_msg);
CAMLlocal4(v,s,t,ans);
GstMessage *msg = Message_val(_msg);
GstTagList *tags = NULL;
const GValue *val;
const gchar *tag;
int taglen;
int i, j, n;
caml_release_runtime_system();
gst_message_parse_tag(msg, &tags);
taglen = gst_tag_list_n_tags(tags);
caml_acquire_runtime_system();
ans = caml_alloc_tuple(taglen);
for(i = 0; i < taglen; i++)
{
t = caml_alloc_tuple(2);
// Tag name
tag = gst_tag_list_nth_tag_name(tags, i);
Store_field(t, 0, caml_copy_string(tag));
// Tag fields
n = gst_tag_list_get_tag_size(tags, tag);
v = caml_alloc_tuple(n);
for (j = 0; j < n; j++)
{
val = gst_tag_list_get_value_index(tags, tag, j);
if (G_VALUE_HOLDS_STRING(val)) {
s = caml_copy_string(g_value_get_string(val));
}
else if (GST_VALUE_HOLDS_DATE_TIME(val)) {
GstDateTime *dt = g_value_get_boxed(val);
gchar *dt_str = gst_date_time_to_iso8601_string(dt);
s = caml_copy_string(dt_str);
g_free(dt_str);
}
else {
//TODO: better typed handling of non-string values?
char *vc = g_strdup_value_contents(val);
s = caml_copy_string(vc);
free(vc);
}
Store_field(v, j, s);
}
Store_field(t, 1, v);
Store_field(ans, i, t);
}
gst_tag_list_unref(tags);
CAMLreturn(ans);
}
static GstStateChangeReturn
gst_wavenc_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GstWavEnc *wavenc = GST_WAVENC (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
wavenc->format = 0;
wavenc->channels = 0;
wavenc->width = 0;
wavenc->rate = 0;
/* use bogus size initially, we'll write the real
* header when we get EOS and know the exact length */
wavenc->audio_length = 0x7FFF0000;
wavenc->meta_length = 0;
wavenc->sent_header = FALSE;
/* its true because we haven't writen anything */
wavenc->finished_properly = TRUE;
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (ret != GST_STATE_CHANGE_SUCCESS)
return ret;
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
if (!wavenc->finished_properly) {
GST_ELEMENT_WARNING (wavenc, STREAM, MUX,
("Wav stream not finished properly"),
("Wav stream not finished properly, no EOS received "
"before shutdown"));
}
break;
case GST_STATE_CHANGE_READY_TO_NULL:
GST_DEBUG_OBJECT (wavenc, "tags: %p", wavenc->tags);
if (wavenc->tags) {
gst_tag_list_unref (wavenc->tags);
wavenc->tags = NULL;
}
GST_DEBUG_OBJECT (wavenc, "toc: %p", wavenc->toc);
if (wavenc->toc) {
gst_toc_unref (wavenc->toc);
wavenc->toc = NULL;
}
gst_tag_setter_reset_tags (GST_TAG_SETTER (wavenc));
gst_toc_setter_reset (GST_TOC_SETTER (wavenc));
break;
default:
break;
}
return ret;
}
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);
}
/**
* gst_toc_set_tags:
* @toc: A #GstToc instance
* @tags: (allow-none) (transfer full): A #GstTagList or %NULL
*
* Set a #GstTagList with tags for the complete @toc.
*/
void
gst_toc_set_tags (GstToc * toc, GstTagList * tags)
{
g_return_if_fail (toc != NULL);
g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (toc)));
if (toc->tags)
gst_tag_list_unref (toc->tags);
toc->tags = tags;
}
static inline void
free_tagnode (TagNode * tagnode)
{
g_free (tagnode->str_open);
g_free (tagnode->str_close);
if (tagnode->taglist)
gst_tag_list_unref (tagnode->taglist);
g_slice_free (TagNode, tagnode);
}
/**
* gst_toc_entry_set_tags:
* @entry: A #GstTocEntry instance
* @tags: (allow-none) (transfer full): A #GstTagList or %NULL
*
* Set a #GstTagList with tags for the complete @entry.
*/
void
gst_toc_entry_set_tags (GstTocEntry * entry, GstTagList * tags)
{
g_return_if_fail (entry != NULL);
g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (entry)));
if (entry->tags)
gst_tag_list_unref (entry->tags);
entry->tags = tags;
}
static gboolean
bus_callback (GstBus * bus, GstMessage * message, gpointer data)
{
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_WARNING:{
GError *err;
gchar *debug;
gst_message_parse_warning (message, &err, &debug);
g_print ("Warning: %s\n", err->message);
g_error_free (err);
g_free (debug);
break;
}
case GST_MESSAGE_ERROR:{
GError *err;
gchar *debug = NULL;
gst_message_parse_error (message, &err, &debug);
g_print ("Error: %s : %s\n", err->message, debug);
g_error_free (err);
g_free (debug);
gtk_main_quit ();
break;
}
case GST_MESSAGE_TAG:{
GstTagList *tags;
GValue v = { 0, };
g_print ("Got tags\n");
gst_message_parse_tag (message, &tags);
if (gst_tag_list_copy_value (&v, tags, "mxf-structure")) {
const GstStructure *s;
GtkTreeIter iter;
s = gst_value_get_structure (&v);
gtk_tree_store_append (treestore, &iter, NULL);
insert_structure (s, &iter);
gtk_widget_show_all (window);
g_value_unset (&v);
}
gst_tag_list_unref (tags);
break;
}
default:
break;
}
return TRUE;
}
