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;
}
static void
gst_wavpack_dec_post_tags (GstWavpackDec * dec)
{
GstTagList *list;
GstFormat format_time = GST_FORMAT_TIME, format_bytes = GST_FORMAT_BYTES;
gint64 duration, size;
list = gst_tag_list_new ();
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_AUDIO_CODEC, "Wavpack", NULL);
/* try to estimate the average bitrate */
if (gst_pad_query_peer_duration (dec->sinkpad, &format_bytes, &size) &&
gst_pad_query_peer_duration (dec->sinkpad, &format_time, &duration) &&
size > 0 && duration > 0) {
guint64 bitrate;
bitrate = gst_util_uint64_scale (size, 8 * GST_SECOND, duration);
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, GST_TAG_BITRATE,
(guint) bitrate, NULL);
}
gst_element_post_message (GST_ELEMENT (dec),
gst_message_new_tag (GST_OBJECT (dec), list));
}
static GstFlowReturn
opus_dec_chain_parse_comments (GstOpusDec * dec, GstBuffer * buf)
{
GstTagList *list;
gchar *encoder = NULL;
list = gst_tag_list_from_vorbiscomment_buffer (buf, NULL, 0, &encoder);
if (!list) {
GST_WARNING_OBJECT (dec, "couldn't decode comments");
list = gst_tag_list_new ();
}
if (encoder) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_ENCODER, encoder, NULL);
}
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_AUDIO_CODEC, "Opus", NULL);
if (dec->header.bytes_per_packet > 0) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_BITRATE, (guint) dec->header.bytes_per_packet * 8, NULL);
}
GST_INFO_OBJECT (dec, "tags: %" GST_PTR_FORMAT, list);
gst_element_found_tags_for_pad (GST_ELEMENT (dec), dec->srcpad, list);
g_free (encoder);
g_free (ver);
return GST_FLOW_OK;
}
static void
read_one_tag (GstTagList * list, const gchar * tag, XmpTag * xmptag,
const gchar * v, GSList ** pending_tags)
{
GType tag_type;
if (xmptag && xmptag->deserialize) {
xmptag->deserialize (list, tag, xmptag->tag_name, v, pending_tags);
return;
}
tag_type = gst_tag_get_type (tag);
/* add gstreamer tag depending on type */
switch (tag_type) {
case G_TYPE_STRING:{
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, tag, v, NULL);
break;
}
default:
if (tag_type == GST_TYPE_DATE) {
GDate *date;
gint d, m, y;
/* this is ISO 8601 Date and Time Format
* %F Equivalent to %Y-%m-%d (the ISO 8601 date format). (C99)
* %T The time in 24-hour notation (%H:%M:%S). (SU)
* e.g. 2009-05-30T18:26:14+03:00 */
/* FIXME: this would be the proper way, but needs
#define _XOPEN_SOURCE before #include <time.h>
date = g_date_new ();
struct tm tm={0,};
strptime (dts, "%FT%TZ", &tm);
g_date_set_time_t (date, mktime(&tm));
*/
/* FIXME: this cannot parse the date
date = g_date_new ();
g_date_set_parse (date, v);
if (g_date_valid (date)) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, tag,
date, NULL);
} else {
GST_WARNING ("unparsable date: '%s'", v);
}
*/
/* poor mans straw */
sscanf (v, "%04d-%02d-%02dT", &y, &m, &d);
date = g_date_new_dmy (d, m, y);
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, tag, date, NULL);
g_date_free (date);
} else {
GST_WARNING ("unhandled type for %s from xmp", tag);
}
break;
}
}
static gboolean
gst_vaapiencode_set_format (GstVideoEncoder * venc, GstVideoCodecState * state)
{
GstVaapiEncode *const encode = GST_VAAPIENCODE_CAST (venc);
gboolean ret;
g_return_val_if_fail (state->caps != NULL, FALSE);
if (!set_codec_state (encode, state))
return FALSE;
if (!gst_vaapi_plugin_base_set_caps (GST_VAAPI_PLUGIN_BASE (encode),
state->caps, NULL))
return FALSE;
if (encode->input_state)
gst_video_codec_state_unref (encode->input_state);
encode->input_state = gst_video_codec_state_ref (state);
encode->input_state_changed = TRUE;
ret = gst_pad_start_task (GST_VAAPI_PLUGIN_BASE_SRC_PAD (encode),
(GstTaskFunction) gst_vaapiencode_buffer_loop, encode, NULL);
if (!ret)
return FALSE;
/* Store some tags */
{
GstTagList *tags = gst_tag_list_new_empty ();
const gchar *encoder, *codec;
guint bitrate = 0;
g_object_get (encode, "bitrate", &bitrate, NULL);
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_NOMINAL_BITRATE,
bitrate, NULL);
if ((encoder =
gst_element_class_get_metadata (GST_ELEMENT_GET_CLASS (encode),
GST_ELEMENT_METADATA_LONGNAME)))
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_ENCODER, encoder,
NULL);
if ((codec =
gst_vaapi_codec_get_name (gst_vaapi_profile_get_codec
(gst_vaapi_profile_from_caps (state->caps)))))
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_CODEC, codec,
NULL);
gst_video_encoder_merge_tags (venc, tags, GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (tags);
}
return TRUE;
}
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
gst_icydemux_parse_and_send_tags (GstICYDemux * icydemux)
{
GstTagList *tags;
const guint8 *data;
int length, i;
gchar *buffer;
gchar **strings;
length = gst_adapter_available (icydemux->meta_adapter);
data = gst_adapter_peek (icydemux->meta_adapter, length);
/* Now, copy this to a buffer where we can NULL-terminate it to make things
* a bit easier, then do that parsing. */
buffer = g_strndup ((const gchar *) data, length);
tags = gst_tag_list_new ();
strings = g_strsplit (buffer, "';", 0);
for (i = 0; strings[i]; i++) {
if (!g_ascii_strncasecmp (strings[i], "StreamTitle=", 12)) {
char *title = gst_icydemux_unicodify (strings[i] + 13);
if (title && *title) {
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_TITLE,
title, NULL);
g_free (title);
}
} else if (!g_ascii_strncasecmp (strings[i], "StreamUrl=", 10)) {
char *url = gst_icydemux_unicodify (strings[i] + 11);
if (url && *url) {
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_HOMEPAGE,
url, NULL);
g_free (url);
}
}
}
g_strfreev (strings);
g_free (buffer);
gst_adapter_clear (icydemux->meta_adapter);
if (!gst_tag_list_is_empty (tags))
gst_icydemux_tag_found (icydemux, tags);
else
gst_tag_list_free (tags);
}
static void
create_fingerprint (GstOFA * ofa)
{
GstBuffer *buf;
gint rate = GST_AUDIO_FILTER (ofa)->format.rate;
gint channels = GST_AUDIO_FILTER (ofa)->format.channels;
gint endianness =
(GST_AUDIO_FILTER (ofa)->format.
bigend) ? OFA_BIG_ENDIAN : OFA_LITTLE_ENDIAN;
GstTagList *tags;
GST_DEBUG ("Generating fingerprint");
buf =
gst_adapter_take_buffer (ofa->adapter,
gst_adapter_available (ofa->adapter));
ofa->fingerprint = g_strdup (ofa_create_print (GST_BUFFER_DATA (buf),
endianness, GST_BUFFER_SIZE (buf) / 2, rate,
(channels == 2) ? 1 : 0));
GST_DEBUG ("Generated fingerprint");
gst_buffer_unref (buf);
tags = gst_tag_list_new ();
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE,
GST_TAG_OFA_FINGERPRINT, ofa->fingerprint, NULL);
gst_element_found_tags (GST_ELEMENT (ofa), tags);
ofa->record = FALSE;
}
/**
* gst_pb_utils_add_codec_description_to_tag_list:
* @taglist: a #GstTagList
* @codec_tag: a GStreamer codec tag such as #GST_TAG_AUDIO_CODEC,
* #GST_TAG_VIDEO_CODEC or #GST_TAG_CODEC
* @caps: the (fixed) #GstCaps for which a codec tag should be added.
*
* Adds a codec tag describing the format specified by @caps to @taglist.
*
* Returns: TRUE if a codec tag was added, FALSE otherwise.
*/
gboolean
gst_pb_utils_add_codec_description_to_tag_list (GstTagList * taglist,
const gchar * codec_tag, const GstCaps * caps)
{
const FormatInfo *info;
gchar *desc;
g_return_val_if_fail (taglist != NULL, FALSE);
g_return_val_if_fail (GST_IS_TAG_LIST (taglist), FALSE);
g_return_val_if_fail (codec_tag != NULL, FALSE);
g_return_val_if_fail (gst_tag_exists (codec_tag), FALSE);
g_return_val_if_fail (gst_tag_get_type (codec_tag) == G_TYPE_STRING, FALSE);
g_return_val_if_fail (caps != NULL, FALSE);
g_return_val_if_fail (GST_IS_CAPS (caps), FALSE);
info = find_format_info (caps);
if (info == NULL)
return FALSE;
desc = format_info_get_desc (info, caps);
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, codec_tag, desc, NULL);
g_free (desc);
return TRUE;
}
static gboolean
gst_rg_analysis_album_result (GstRgAnalysis * filter, GstTagList ** tag_list)
{
gboolean album_success;
gdouble album_gain, album_peak;
album_success = rg_analysis_album_result (filter->ctx, &album_gain,
&album_peak);
if (album_success) {
album_gain += filter->reference_level - RG_REFERENCE_LEVEL;
GST_INFO_OBJECT (filter, "album gain is %+.2f dB, peak %.6f", album_gain,
album_peak);
} else {
GST_INFO_OBJECT (filter, "album was too short to analyze");
}
if (album_success) {
if (*tag_list == NULL)
*tag_list = gst_tag_list_new_empty ();
gst_tag_list_add (*tag_list, GST_TAG_MERGE_APPEND,
GST_TAG_ALBUM_PEAK, album_peak, GST_TAG_ALBUM_GAIN, album_gain, NULL);
}
return album_success;
}
static gboolean
gst_rg_analysis_track_result (GstRgAnalysis * filter, GstTagList ** tag_list)
{
gboolean track_success;
gdouble track_gain, track_peak;
track_success = rg_analysis_track_result (filter->ctx, &track_gain,
&track_peak);
if (track_success) {
track_gain += filter->reference_level - RG_REFERENCE_LEVEL;
GST_INFO_OBJECT (filter, "track gain is %+.2f dB, peak %.6f", track_gain,
track_peak);
} else {
GST_INFO_OBJECT (filter, "track was too short to analyze");
}
if (track_success) {
if (*tag_list == NULL)
*tag_list = gst_tag_list_new_empty ();
gst_tag_list_add (*tag_list, GST_TAG_MERGE_APPEND,
GST_TAG_TRACK_PEAK, track_peak, GST_TAG_TRACK_GAIN, track_gain, NULL);
}
return track_success;
}
/* read comment and post as tag */
static inline gboolean
gst_jpeg_parse_com (GstJpegParse * parse, GstByteReader * reader)
{
const guint8 *data = NULL;
guint16 size = 0;
gchar *comment;
if (!gst_byte_reader_get_uint16_be (reader, &size))
return FALSE;
size -= 2;
if (!gst_byte_reader_get_data (reader, size, &data))
return FALSE;
comment = get_utf8_from_data (data, size);
if (comment) {
GstTagList *taglist = get_tag_list (parse);
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE,
GST_TAG_COMMENT, comment, NULL);
GST_DEBUG_OBJECT (parse, "collected tags: %" GST_PTR_FORMAT, taglist);
g_free (comment);
}
return TRUE;
}
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);
}
static gint
deserialize_orientation (GstExifReader * exif_reader,
GstByteReader * reader, const GstExifTagMatch * exiftag,
GstExifTagData * tagdata)
{
gint ret = 1;
const gchar *str = NULL;
gint value;
GST_LOG ("Starting to parse %s tag in exif 0x%x", exiftag->gst_tag,
exiftag->exif_tag);
/* validate tag */
if (tagdata->tag_type != EXIF_TYPE_SHORT || tagdata->count != 1) {
GST_WARNING ("Orientation tag has unexpected type/count");
return ret;
}
if (exif_reader->byte_order == G_LITTLE_ENDIAN) {
value = GST_READ_UINT16_LE (tagdata->offset_as_data);
} else {
value = GST_READ_UINT16_BE (tagdata->offset_as_data);
}
str = gst_tag_image_orientation_from_exif_value (value);
if (str == NULL) {
GST_WARNING ("Invalid value for exif orientation tag: %d", value);
return ret;
}
gst_tag_list_add (exif_reader->taglist, GST_TAG_MERGE_REPLACE,
exiftag->gst_tag, str, NULL);
return ret;
}
static void
parse_exif_ascii_tag (GstExifReader * reader, const gchar * gst_tag,
guint32 count, guint32 offset, const guint8 * offset_as_data)
{
gchar *str;
guint32 real_offset;
if (count > 4) {
if (offset < reader->base_offset) {
GST_WARNING ("Offset is smaller (%u) than base offset (%u)", offset,
reader->base_offset);
return;
}
real_offset = offset - reader->base_offset;
if (real_offset >= GST_BUFFER_SIZE (reader->buffer)) {
GST_WARNING ("Invalid offset %u for buffer of size %u, not adding tag %s",
real_offset, GST_BUFFER_SIZE (reader->buffer), gst_tag);
return;
}
str =
g_strndup ((gchar *) (GST_BUFFER_DATA (reader->buffer) + real_offset),
count);
} else {
str = g_strndup ((gchar *) offset_as_data, count);
}
gst_tag_list_add (reader->taglist, GST_TAG_MERGE_REPLACE, gst_tag, str, NULL);
g_free (str);
}
static void
gst_trm_emit_signature (GstTRM * trm)
{
char signature[17];
char ascii_sig[37];
if (trm->signature_available)
return;
if (trm_FinalizeSignature (trm->trm, signature, NULL) == 0) {
GstTagList *tags;
trm_ConvertSigToASCII (trm->trm, signature, ascii_sig);
ascii_sig[36] = '\0';
GST_DEBUG_OBJECT (trm, "Signature : %s", ascii_sig);
tags = gst_tag_list_new ();
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE,
GST_TAG_MUSICBRAINZ_TRMID, ascii_sig, NULL);
gst_element_found_tags_for_pad (GST_ELEMENT (trm), trm->srcpad, tags);
trm->signature_available = TRUE;
} else {
/* FIXME: should we be throwing an error here? */
}
}
/* 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 GstTagList *
test_taglib_apev2mux_create_tags (guint32 mask)
{
GstTagList *tags;
tags = gst_tag_list_new_empty ();
if (mask & (1 << 0)) {
gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
GST_TAG_ARTIST, TEST_ARTIST, NULL);
}
if (mask & (1 << 1)) {
gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
GST_TAG_TITLE, TEST_TITLE, NULL);
}
if (mask & (1 << 2)) {
gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
GST_TAG_ALBUM, TEST_ALBUM, NULL);
}
if (mask & (1 << 3)) {
GDate *date;
date = TEST_DATE;
gst_tag_list_add (tags, GST_TAG_MERGE_KEEP, GST_TAG_DATE, date, NULL);
g_date_free (date);
}
if (mask & (1 << 4)) {
gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
GST_TAG_TRACK_NUMBER, TEST_TRACK_NUMBER, NULL);
}
if (mask & (1 << 5)) {
gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
GST_TAG_TRACK_COUNT, TEST_TRACK_COUNT, NULL);
}
if (mask & (1 << 6)) {
gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
GST_TAG_TRACK_GAIN, TEST_TRACK_GAIN, NULL);
}
if (mask & (1 << 7)) {
gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
GST_TAG_ALBUM_GAIN, TEST_ALBUM_GAIN, NULL);
}
if (mask & (1 << 8)) {
}
if (mask & (1 << 9)) {
}
if (mask & (1 << 10)) {
}
if (mask & (1 << 11)) {
}
if (mask & (1 << 12)) {
}
if (mask & (1 << 13)) {
}
return tags;
}
static GstFlowReturn
gst_speex_dec_parse_comments (GstSpeexDec * dec, GstBuffer * buf)
{
GstTagList *list;
gchar *ver, *encoder = NULL;
list = gst_tag_list_from_vorbiscomment_buffer (buf, NULL, 0, &encoder);
if (!list) {
GST_WARNING_OBJECT (dec, "couldn't decode comments");
list = gst_tag_list_new ();
}
if (encoder) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_ENCODER, encoder, NULL);
}
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_AUDIO_CODEC, "Speex", NULL);
ver = g_strndup (dec->header->speex_version, SPEEX_HEADER_VERSION_LENGTH);
g_strstrip (ver);
if (ver != NULL && *ver != '\0') {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_ENCODER_VERSION, ver, NULL);
}
if (dec->header->bitrate > 0) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_BITRATE, (guint) dec->header->bitrate, NULL);
}
GST_INFO_OBJECT (dec, "tags: %" GST_PTR_FORMAT, list);
gst_audio_decoder_merge_tags (GST_AUDIO_DECODER (dec), list,
GST_TAG_MERGE_REPLACE);
gst_tag_list_free (list);
g_free (encoder);
g_free (ver);
return GST_FLOW_OK;
}
/**
* gst_avi_subtitle_title_tag:
* @sub: subtitle element
* @title: the title of this subtitle stream
*
* Send an event to the srcpad of the @sub element with the title
* of the subtitle stream as a GST_TAG_TITLE
*/
static void
gst_avi_subtitle_title_tag (GstAviSubtitle * sub, gchar * title)
{
GstTagList *temp_list = gst_tag_list_new ();
gst_tag_list_add (temp_list, GST_TAG_MERGE_APPEND, GST_TAG_TITLE, title,
NULL);
gst_pad_push_event (sub->src, gst_event_new_tag (temp_list));
}
EXPORT_C
#endif
GstTagList *
gst_tag_list_new_from_id3v1 (const guint8 * data)
{
guint year;
gchar *ystr;
GstTagList *list;
g_return_val_if_fail (data != NULL, NULL);
if (data[0] != 'T' || data[1] != 'A' || data[2] != 'G')
return NULL;
list = gst_tag_list_new ();
gst_tag_extract_id3v1_string (list, GST_TAG_TITLE, (gchar *) & data[3], 30);
gst_tag_extract_id3v1_string (list, GST_TAG_ARTIST, (gchar *) & data[33], 30);
gst_tag_extract_id3v1_string (list, GST_TAG_ALBUM, (gchar *) & data[63], 30);
ystr = g_strndup ((gchar *) & data[93], 4);
year = strtoul (ystr, NULL, 10);
g_free (ystr);
if (year > 0) {
GDate *date = g_date_new_dmy (1, 1, year);
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, GST_TAG_DATE, date, NULL);
g_date_free (date);
}
if (data[125] == 0 && data[126] != 0) {
gst_tag_extract_id3v1_string (list, GST_TAG_COMMENT, (gchar *) & data[97],
28);
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, GST_TAG_TRACK_NUMBER,
(guint) data[126], NULL);
} else {
gst_tag_extract_id3v1_string (list, GST_TAG_COMMENT, (gchar *) & data[97],
30);
}
if (data[127] < gst_tag_id3_genre_count () && !gst_tag_list_is_empty (list)) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, GST_TAG_GENRE,
gst_tag_id3_genre_get (data[127]), NULL);
}
return list;
}
static GstFlowReturn
theora_handle_comment_packet (GstTheoraDec * dec, ogg_packet * packet)
{
gchar *encoder = NULL;
GstBuffer *buf;
GstTagList *list;
GST_DEBUG_OBJECT (dec, "parsing comment packet");
buf = gst_buffer_new ();
GST_BUFFER_SIZE (buf) = packet->bytes;
GST_BUFFER_DATA (buf) = packet->packet;
list =
gst_tag_list_from_vorbiscomment_buffer (buf, (guint8 *) "\201theora", 7,
&encoder);
gst_buffer_unref (buf);
if (!list) {
GST_ERROR_OBJECT (dec, "couldn't decode comments");
list = gst_tag_list_new ();
}
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, "Theora", NULL);
if (dec->info.target_bitrate > 0) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_BITRATE, dec->info.target_bitrate,
GST_TAG_NOMINAL_BITRATE, dec->info.target_bitrate, NULL);
}
dec->tags = list;
return GST_FLOW_OK;
}
static void
parse_exif_rational_tag (GstExifReader * exif_reader,
const gchar * gst_tag, guint32 count, guint32 offset, gdouble multiplier)
{
GstByteReader data_reader;
guint32 real_offset;
guint32 frac_n = 0;
guint32 frac_d = 1;
gdouble value;
if (count > 1) {
GST_WARNING ("Rationals with multiple entries are not supported");
}
if (offset < exif_reader->base_offset) {
GST_WARNING ("Offset is smaller (%u) than base offset (%u)", offset,
exif_reader->base_offset);
return;
}
real_offset = offset - exif_reader->base_offset;
if (real_offset >= GST_BUFFER_SIZE (exif_reader->buffer)) {
GST_WARNING ("Invalid offset %u for buffer of size %u, not adding tag %s",
real_offset, GST_BUFFER_SIZE (exif_reader->buffer), gst_tag);
return;
}
gst_byte_reader_init_from_buffer (&data_reader, exif_reader->buffer);
if (!gst_byte_reader_set_pos (&data_reader, real_offset))
goto reader_fail;
if (exif_reader->byte_order == G_LITTLE_ENDIAN) {
if (!gst_byte_reader_get_uint32_le (&data_reader, &frac_n) ||
!gst_byte_reader_get_uint32_le (&data_reader, &frac_d))
goto reader_fail;
} else {
if (!gst_byte_reader_get_uint32_be (&data_reader, &frac_n) ||
!gst_byte_reader_get_uint32_be (&data_reader, &frac_d))
goto reader_fail;
}
GST_DEBUG ("Read fraction for tag %s: %u/%u", gst_tag, frac_n, frac_d);
gst_util_fraction_to_double (frac_n, frac_d, &value);
value *= multiplier;
GST_DEBUG ("Adding %s tag: %lf", gst_tag, value);
gst_tag_list_add (exif_reader->taglist, GST_TAG_MERGE_REPLACE, gst_tag, value,
NULL);
return;
reader_fail:
GST_WARNING ("Failed to read from byte reader. (Buffer too short?)");
}
static void
create_fingerprint (GstOFA * ofa)
{
GstBuffer *buf;
GstAudioFilter *ofa_filter = GST_AUDIO_FILTER (ofa);
gint rate = ofa_filter->format.rate;
gint channels = ofa_filter->format.channels;
gint endianness =
ofa_filter->format.bigend ? OFA_BIG_ENDIAN : OFA_LITTLE_ENDIAN;
GstTagList *tags;
guint available;
available = gst_adapter_available (ofa->adapter);
if (available == 0) {
GST_WARNING_OBJECT (ofa, "No data to take fingerprint from");
ofa->record = FALSE;
return;
}
if (GST_AUDIO_FILTER (ofa)->format.bigend)
endianness = OFA_BIG_ENDIAN;
else
endianness = OFA_LITTLE_ENDIAN;
GST_DEBUG_OBJECT (ofa, "Generating fingerprint for %u samples",
available / 2);
buf = gst_adapter_take_buffer (ofa->adapter, available);
ofa->fingerprint = g_strdup (ofa_create_print (GST_BUFFER_DATA (buf),
endianness, GST_BUFFER_SIZE (buf) / 2, rate,
(channels == 2) ? 1 : 0));
if (ofa->fingerprint) {
GST_INFO_OBJECT (ofa, "Generated fingerprint: %s", ofa->fingerprint);
} else {
GST_WARNING_OBJECT (ofa, "Failed to generate fingerprint");
}
gst_buffer_unref (buf);
if (ofa->fingerprint) {
tags = gst_tag_list_new ();
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE,
GST_TAG_OFA_FINGERPRINT, ofa->fingerprint, NULL);
gst_element_found_tags (GST_ELEMENT (ofa), tags);
g_object_notify (G_OBJECT (ofa), "fingerprint");
}
ofa->record = FALSE;
}
/* send a TAG_MESSAGE event for a clip */
static void
gst_cmml_dec_send_clip_tag (GstCmmlDec * dec, GstCmmlTagClip * clip)
{
GstTagList *tags;
GST_DEBUG_OBJECT (dec, "sending clip tag %s", clip->id);
tags = gst_tag_list_new ();
gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, GST_TAG_CMML_CLIP, clip, NULL);
gst_element_found_tags_for_pad (GST_ELEMENT (dec), dec->srcpad, tags);
}
static void
gst_vp9_dec_send_tags (GstVP9Dec * dec)
{
GstTagList *list;
list = gst_tag_list_new_empty ();
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_VIDEO_CODEC, "VP9 video", NULL);
gst_pad_push_event (GST_VIDEO_DECODER_SRC_PAD (dec),
gst_event_new_tag (list));
}
static void
gst_dtsdec_update_streaminfo (GstDtsDec * dts)
{
GstTagList *taglist;
taglist = gst_tag_list_new ();
gst_tag_list_add (taglist, GST_TAG_MERGE_APPEND,
GST_TAG_BITRATE, (guint) dts->bit_rate, NULL);
gst_element_found_tags_for_pad (GST_ELEMENT (dts), dts->srcpad, taglist);
}
static void
gst_schrodec_send_tags (GstSchroDec *schro_dec)
{
GstTagList *list;
list = gst_tag_list_new ();
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
GST_TAG_VIDEO_CODEC, "Dirac", NULL);
gst_element_found_tags_for_pad (GST_ELEMENT_CAST (schro_dec),
schro_dec->srcpad, list);
}
GstTagList *
gst_rm_utils_read_tags (const guint8 * data, guint datalen,
GstRmUtilsStringReadFunc read_string_func)
{
const gchar *gst_tags[] = { GST_TAG_TITLE, GST_TAG_ARTIST,
GST_TAG_COPYRIGHT, GST_TAG_COMMENT
};
GstTagList *tags;
guint i;
g_assert (read_string_func != NULL);
GST_DEBUG ("File Content : (CONT) len = %d", datalen);
tags = gst_tag_list_new ();
for (i = 0; i < G_N_ELEMENTS (gst_tags); ++i) {
gchar *str = NULL;
guint total_length = 0;
str = read_string_func (data, datalen, &total_length);
data += total_length;
datalen -= total_length;
if (str != NULL && !g_utf8_validate (str, -1, NULL)) {
const gchar *encoding;
gchar *tmp;
encoding = g_getenv ("GST_TAG_ENCODING");
if (encoding == NULL || *encoding == '\0') {
if (g_get_charset (&encoding))
encoding = "ISO-8859-15";
}
GST_DEBUG ("converting tag from %s to UTF-8", encoding);
tmp = g_convert_with_fallback (str, -1, "UTF-8", encoding, "*",
NULL, NULL, NULL);
g_free (str);
str = tmp;
}
GST_DEBUG ("%s = %s", gst_tags[i], GST_STR_NULL (str));
if (str != NULL && *str != '\0') {
gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, gst_tags[i], str, NULL);
}
g_free (str);
}
if (gst_structure_n_fields ((GstStructure *) tags) > 0)
return tags;
gst_tag_list_free (tags);
return NULL;
}
static GstCaps *
mxf_vc3_create_caps (MXFMetadataTimelineTrack * track, GstTagList ** tags,
MXFEssenceElementHandleFunc * handler, gpointer * mapping_data)
{
MXFMetadataFileDescriptor *f = NULL;
MXFMetadataGenericPictureEssenceDescriptor *p = NULL;
guint i;
GstCaps *caps = NULL;
g_return_val_if_fail (track != NULL, NULL);
if (track->parent.descriptor == NULL) {
GST_ERROR ("No descriptor found for this track");
return NULL;
}
for (i = 0; i < track->parent.n_descriptor; i++) {
if (!track->parent.descriptor[i])
continue;
if (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (track->
parent.descriptor[i])) {
p = (MXFMetadataGenericPictureEssenceDescriptor *) track->parent.
descriptor[i];
f = track->parent.descriptor[i];
break;
} else if (MXF_IS_METADATA_FILE_DESCRIPTOR (track->parent.descriptor[i]) &&
!MXF_IS_METADATA_MULTIPLE_DESCRIPTOR (track->parent.descriptor[i])) {
f = track->parent.descriptor[i];
}
}
if (!f) {
GST_ERROR ("No descriptor found for this track");
return NULL;
}
*handler = mxf_vc3_handle_essence_element;
caps = gst_caps_new_empty_simple ("video/x-dnxhd");
if (p) {
mxf_metadata_generic_picture_essence_descriptor_set_caps (p, caps);
} else {
GST_WARNING ("Only a generic file descriptor found");
}
if (!*tags)
*tags = gst_tag_list_new_empty ();
gst_tag_list_add (*tags, GST_TAG_MERGE_APPEND, GST_TAG_VIDEO_CODEC,
"VC-3 Video", NULL);
return caps;
}
