static GstFlowReturn
gst_mpegv_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
{
GstMpegvParse *mpvparse = GST_MPEGVIDEO_PARSE (parse);
GstTagList *taglist;
/* tag sending done late enough in hook to ensure pending events
* have already been sent */
if (G_UNLIKELY (mpvparse->send_codec_tag)) {
gchar *codec;
/* codec tag */
codec =
g_strdup_printf ("MPEG %d Video",
(mpvparse->config_flags & FLAG_MPEG2) ? 2 : 1);
taglist = gst_tag_list_new (GST_TAG_VIDEO_CODEC, codec, NULL);
g_free (codec);
gst_pad_push_event (GST_BASE_PARSE_SRC_PAD (mpvparse),
gst_event_new_tag (taglist));
mpvparse->send_codec_tag = FALSE;
}
/* usual clipping applies */
frame->flags |= GST_BASE_PARSE_FRAME_FLAG_CLIP;
return GST_FLOW_OK;
}
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? */
}
}
static void
brasero_transcode_send_volume_event (BraseroTranscode *transcode)
{
BraseroTranscodePrivate *priv;
gdouble track_peak = 0.0;
gdouble track_gain = 0.0;
GstTagList *tag_list;
BraseroTrack *track;
GstEvent *event;
GValue *value;
priv = BRASERO_TRANSCODE_PRIVATE (transcode);
brasero_job_get_current_track (BRASERO_JOB (transcode), &track);
BRASERO_JOB_LOG (transcode, "Sending audio levels tags");
if (brasero_track_tag_lookup (track, BRASERO_TRACK_PEAK_VALUE, &value) == BRASERO_BURN_OK)
track_peak = g_value_get_double (value);
if (brasero_track_tag_lookup (track, BRASERO_TRACK_GAIN_VALUE, &value) == BRASERO_BURN_OK)
track_gain = g_value_get_double (value);
/* it's possible we fail */
tag_list = gst_tag_list_new (GST_TAG_TRACK_GAIN, track_gain,
GST_TAG_TRACK_PEAK, track_peak,
NULL);
/* NOTE: that event is goind downstream */
event = gst_event_new_tag (tag_list);
if (!gst_element_send_event (priv->convert, event))
BRASERO_JOB_LOG (transcode, "Couldn't send tags to rgvolume");
BRASERO_JOB_LOG (transcode, "Set volume level %lf %lf", track_gain, track_peak);
}
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 ();
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_free (empty_tags);
return comments;
}
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 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 inline GstTagList *
get_tag_list (GstJpegParse * parse)
{
if (!parse->priv->tags)
parse->priv->tags = gst_tag_list_new ();
return parse->priv->tags;
}
static void
gst_shout2send_init (GstShout2send * shout2send)
{
gst_base_sink_set_sync (GST_BASE_SINK (shout2send), FALSE);
gst_pad_set_setcaps_function (GST_BASE_SINK_PAD (shout2send),
GST_DEBUG_FUNCPTR (gst_shout2send_setcaps));
shout2send->timer = gst_poll_new_timer ();
shout2send->ip = g_strdup (DEFAULT_IP);
shout2send->port = DEFAULT_PORT;
shout2send->password = g_strdup (DEFAULT_PASSWORD);
shout2send->username = g_strdup (DEFAULT_USERNAME);
shout2send->streamname = g_strdup (DEFAULT_STREAMNAME);
shout2send->description = g_strdup (DEFAULT_DESCRIPTION);
shout2send->genre = g_strdup (DEFAULT_GENRE);
shout2send->mount = g_strdup (DEFAULT_MOUNT);
shout2send->url = g_strdup (DEFAULT_URL);
shout2send->protocol = DEFAULT_PROTOCOL;
shout2send->ispublic = DEFAULT_PUBLIC;
shout2send->tags = gst_tag_list_new ();
shout2send->conn = NULL;
shout2send->audio_format = SHOUT_FORMAT_VORBIS;
shout2send->connected = FALSE;
shout2send->songmetadata = NULL;
shout2send->songartist = NULL;
shout2send->songtitle = NULL;
}
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;
}
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));
}
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 ();
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_free (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_free (tag_list);
g_date_free (date);
}
/**
* 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));
}
static gboolean
gst_vorbis_enc_start (GstAudioEncoder * enc)
{
GstVorbisEnc *vorbisenc = GST_VORBISENC (enc);
GST_DEBUG_OBJECT (enc, "start");
vorbisenc->tags = gst_tag_list_new ();
vorbisenc->header_sent = FALSE;
return TRUE;
}
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 gboolean
gst_opus_enc_start (GstAudioEncoder * benc)
{
GstOpusEnc *enc = GST_OPUS_ENC (benc);
GST_DEBUG_OBJECT (enc, "start");
enc->tags = gst_tag_list_new ();
enc->header_sent = FALSE;
return TRUE;
}
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 gboolean
gst_speex_enc_start (GstAudioEncoder * benc)
{
GstSpeexEnc *enc = GST_SPEEX_ENC (benc);
GST_DEBUG_OBJECT (enc, "start");
speex_bits_init (&enc->bits);
enc->tags = gst_tag_list_new ();
enc->header_sent = FALSE;
return TRUE;
}
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);
}
static GstCaps *
mxf_alaw_create_caps (MXFMetadataTimelineTrack * track, GstTagList ** tags,
MXFEssenceElementHandleFunc * handler, gpointer * mapping_data)
{
MXFMetadataGenericSoundEssenceDescriptor *s = 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_SOUND_ESSENCE_DESCRIPTOR (track->parent.
descriptor[i])) {
s = (MXFMetadataGenericSoundEssenceDescriptor *) track->parent.
descriptor[i];
break;
}
}
if (!s) {
GST_ERROR ("No generic sound essence descriptor found for this track");
return NULL;
}
*handler = mxf_alaw_handle_essence_element;
if (s && s->audio_sampling_rate.n != 0 && s->audio_sampling_rate.d != 0 &&
s->channel_count != 0) {
caps = gst_caps_new_simple ("audio/x-alaw", NULL);
mxf_metadata_generic_sound_essence_descriptor_set_caps (s, caps);
/* TODO: Handle channel layout somehow?
* Or is alaw limited to two channels? */
if (!*tags)
*tags = gst_tag_list_new ();
gst_tag_list_add (*tags, GST_TAG_MERGE_APPEND, GST_TAG_AUDIO_CODEC,
"A-law encoded audio", NULL);
}
return caps;
}
static gboolean
mpegts_base_get_tags_from_eit (MpegTSBase * base, GstMpegtsSection * section)
{
const GstMpegtsEIT *eit;
guint i;
MpegTSBaseProgram *program;
/* Early exit if it's not from the present/following table_id */
if (section->table_id != GST_MTS_TABLE_ID_EVENT_INFORMATION_ACTUAL_TS_PRESENT
&& section->table_id !=
GST_MTS_TABLE_ID_EVENT_INFORMATION_OTHER_TS_PRESENT)
return TRUE;
eit = gst_mpegts_section_get_eit (section);
if (G_UNLIKELY (eit == NULL))
return FALSE;
program = mpegts_base_get_program (base, section->subtable_extension);
GST_DEBUG
("program_id:0x%04x, table_id:0x%02x, actual_stream:%d, present_following:%d, program:%p",
section->subtable_extension, section->table_id, eit->actual_stream,
eit->present_following, program);
if (program && eit->present_following) {
for (i = 0; i < eit->events->len; i++) {
GstMpegtsEITEvent *event = g_ptr_array_index (eit->events, i);
const GstMpegtsDescriptor *desc;
if (event->running_status == RUNNING_STATUS_RUNNING) {
program->event_id = event->event_id;
if ((desc =
gst_mpegts_find_descriptor (event->descriptors,
GST_MTS_DESC_DVB_SHORT_EVENT))) {
gchar *name;
if (gst_mpegts_descriptor_parse_dvb_short_event (desc, NULL, &name,
NULL)) {
/* FIXME : Is it correct to post an event duration as a GST_TAG_DURATION ??? */
program->tags =
gst_tag_list_new (GST_TAG_TITLE, name, GST_TAG_DURATION,
event->duration * GST_SECOND, NULL);
g_free (name);
return TRUE;
}
}
}
}
}
return TRUE;
}
static GstStateChangeReturn
gst_speex_enc_change_state (GstElement * element, GstStateChange transition)
{
GstSpeexEnc *enc = GST_SPEEX_ENC (element);
GstStateChangeReturn res;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
enc->tags = gst_tag_list_new ();
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
speex_bits_init (&enc->bits);
enc->frameno = 0;
enc->frameno_out = 0;
enc->samples_in = 0;
enc->start_ts = GST_CLOCK_TIME_NONE;
enc->next_ts = GST_CLOCK_TIME_NONE;
enc->granulepos_offset = 0;
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
/* fall through */
default:
break;
}
res = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (res == GST_STATE_CHANGE_FAILURE)
return res;
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
enc->setup = FALSE;
enc->header_sent = FALSE;
if (enc->state) {
speex_encoder_destroy (enc->state);
enc->state = NULL;
}
speex_bits_destroy (&enc->bits);
break;
case GST_STATE_CHANGE_READY_TO_NULL:
gst_tag_list_free (enc->tags);
enc->tags = NULL;
default:
break;
}
return res;
}
static void
gst_a52dec_update_streaminfo (GstA52Dec * a52dec)
{
GstTagList *taglist;
taglist = gst_tag_list_new ();
gst_tag_list_add (taglist, GST_TAG_MERGE_APPEND,
GST_TAG_AUDIO_CODEC, "Dolby Digital (AC-3)",
GST_TAG_BITRATE, (guint) a52dec->bit_rate, NULL);
gst_element_found_tags_for_pad (GST_ELEMENT (a52dec),
GST_PAD (a52dec->srcpad), taglist);
}
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);
}
/**
* gst_tag_setter_add_tag_valist_values:
* @setter: a #GstTagSetter
* @mode: the mode to use
* @tag: tag to set
* @var_args: tag / GValue pairs to set
*
* Adds the given tag / GValue pairs on the setter using the given merge mode.
* The list must be terminated with NULL.
*/
void
gst_tag_setter_add_tag_valist_values (GstTagSetter * setter,
GstTagMergeMode mode, const gchar * tag, va_list var_args)
{
GstTagData *data;
g_return_if_fail (GST_IS_TAG_SETTER (setter));
g_return_if_fail (GST_TAG_MODE_IS_VALID (mode));
data = gst_tag_setter_get_data (setter);
if (!data->list)
data->list = gst_tag_list_new ();
gst_tag_list_add_valist_values (data->list, mode, tag, var_args);
}
/* GstExifReader functions */
static void
gst_exif_reader_init (GstExifReader * reader, gint byte_order,
const GstBuffer * buf, guint32 base_offset)
{
reader->taglist = gst_tag_list_new ();
reader->buffer = buf;
reader->base_offset = base_offset;
reader->byte_order = byte_order;
if (reader->byte_order != G_LITTLE_ENDIAN &&
reader->byte_order != G_BIG_ENDIAN) {
GST_WARNING ("Unexpected byte order %d, using system default: %d",
reader->byte_order, G_BYTE_ORDER);
reader->byte_order = G_BYTE_ORDER;
}
}
static void
gst_dvdlpcmdec_send_tags (GstDvdLpcmDec * dvdlpcmdec)
{
GstTagList *taglist;
guint bitrate = dvdlpcmdec->channels * dvdlpcmdec->out_width *
dvdlpcmdec->rate;
taglist = gst_tag_list_new ();
gst_tag_list_add (taglist, GST_TAG_MERGE_APPEND,
GST_TAG_AUDIO_CODEC, "LPCM Audio", GST_TAG_BITRATE, bitrate, NULL);
gst_element_found_tags_for_pad (GST_ELEMENT (dvdlpcmdec), dvdlpcmdec->srcpad,
taglist);
}
static GstStateChangeReturn
gst_vorbis_enc_change_state (GstElement * element, GstStateChange transition)
{
GstVorbisEnc *vorbisenc = GST_VORBISENC (element);
GstStateChangeReturn res;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
vorbisenc->tags = gst_tag_list_new ();
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
vorbisenc->setup = FALSE;
vorbisenc->next_discont = FALSE;
vorbisenc->header_sent = FALSE;
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
break;
default:
break;
}
res = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
vorbis_block_clear (&vorbisenc->vb);
vorbis_dsp_clear (&vorbisenc->vd);
vorbis_info_clear (&vorbisenc->vi);
g_free (vorbisenc->last_message);
vorbisenc->last_message = NULL;
if (vorbisenc->srccaps) {
gst_caps_unref (vorbisenc->srccaps);
vorbisenc->srccaps = NULL;
}
break;
case GST_STATE_CHANGE_READY_TO_NULL:
gst_tag_list_free (vorbisenc->tags);
vorbisenc->tags = NULL;
default:
break;
}
return res;
}
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;
}
