/* Print information regarding a stream */
void print_stream_info (GstDiscovererStreamInfo *info, gint depth) {
gchar *desc = NULL;
GstCaps *caps;
const GstTagList *tags;
caps = gst_discoverer_stream_info_get_caps (info);
if (caps) {
if (gst_caps_is_fixed (caps))
desc = gst_pb_utils_get_codec_description (caps);
else
desc = gst_caps_to_string (caps);
gst_caps_unref (caps);
}
g_print ("%*s%s: %s\n", 2 * depth, " ", gst_discoverer_stream_info_get_stream_type_nick (info), (desc ? desc : ""));
if (desc) {
g_free (desc);
desc = NULL;
}
tags = gst_discoverer_stream_info_get_tags (info);
if (tags) {
g_print ("%*sTags:\n", 2 * (depth + 1), " ");
gst_tag_list_foreach (tags, print_tag_foreach, GINT_TO_POINTER (depth + 2));
}
}
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
emit_playing_stream_and_tags (RBPlayerGst *player, gboolean track_change)
{
GList *t;
if (track_change) {
/* swap stream data */
_destroy_stream_data (player);
player->priv->stream_data = player->priv->next_stream_data;
player->priv->stream_data_destroy = player->priv->next_stream_data_destroy;
player->priv->next_stream_data = NULL;
player->priv->next_stream_data_destroy = NULL;
}
_rb_player_emit_playing_stream (RB_PLAYER (player), player->priv->stream_data);
/* process any tag lists we received while starting the stream */
for (t = player->priv->stream_tags; t != NULL; t = t->next) {
GstTagList *tags;
tags = (GstTagList *)t->data;
rb_debug ("processing buffered taglist");
gst_tag_list_foreach (tags, (GstTagForeachFunc) process_tag, player);
gst_tag_list_free (tags);
}
g_list_free (player->priv->stream_tags);
player->priv->stream_tags = NULL;
}
/*!
Convert GstTagList structure to QMap<QByteArray, QVariant>.
Mapping to int, bool, char, string, fractions and date are supported.
Fraction values are converted to doubles.
*/
QMap<QByteArray, QVariant> QGstUtils::gstTagListToMap(const GstTagList *tags)
{
QMap<QByteArray, QVariant> res;
gst_tag_list_foreach(tags, addTagToMap, &res);
return res;
}
static void
print_toc_entry (gpointer data, gpointer user_data)
{
GstTocEntry *entry = (GstTocEntry *) data;
guint depth = GPOINTER_TO_UINT (user_data);
guint indent = MIN (GPOINTER_TO_UINT (user_data), MAX_INDENT);
GstTagList *tags;
GList *subentries;
gint64 start, stop;
gst_toc_entry_get_start_stop_times (entry, &start, &stop);
g_print ("%*s%s: start: %" GST_TIME_FORMAT " stop: %" GST_TIME_FORMAT "\n",
depth, " ",
gst_toc_entry_type_get_nick (gst_toc_entry_get_entry_type (entry)),
GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
indent += 2;
/* print tags */
tags = gst_toc_entry_get_tags (entry);
if (tags) {
g_print ("%*sTags:\n", 2 * depth, " ");
gst_tag_list_foreach (tags, print_tag_foreach, GUINT_TO_POINTER (indent));
}
/* loop over sub-toc entries */
subentries = gst_toc_entry_get_sub_entries (entry);
g_list_foreach (subentries, print_toc_entry, GUINT_TO_POINTER (indent));
}
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);
}
static gboolean
brasero_transcode_bus_messages (GstBus *bus,
GstMessage *msg,
BraseroTranscode *transcode)
{
BraseroTranscodePrivate *priv;
GstTagList *tags = NULL;
GError *error = NULL;
GstState state;
gchar *debug;
priv = BRASERO_TRANSCODE_PRIVATE (transcode);
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_TAG:
/* we use the information to write an .inf file
* for the time being just store the information */
gst_message_parse_tag (msg, &tags);
gst_tag_list_foreach (tags, (GstTagForeachFunc) foreach_tag, transcode);
gst_tag_list_free (tags);
return TRUE;
case GST_MESSAGE_ERROR:
gst_message_parse_error (msg, &error, &debug);
BRASERO_JOB_LOG (transcode, debug);
g_free (debug);
brasero_job_error (BRASERO_JOB (transcode), error);
return FALSE;
case GST_MESSAGE_EOS:
brasero_transcode_song_end_reached (transcode);
return FALSE;
case GST_MESSAGE_STATE_CHANGED: {
GstStateChangeReturn result;
result = gst_element_get_state (priv->pipeline,
&state,
NULL,
1);
if (result != GST_STATE_CHANGE_SUCCESS)
return TRUE;
if (state == GST_STATE_PLAYING)
return brasero_transcode_active_state (transcode);
break;
}
default:
return TRUE;
}
return TRUE;
}
static void
print_all_stream_info (GstPlayerMediaInfo * media_info)
{
guint count = 0;
GList *list, *l;
g_print ("URI : %s\n", gst_player_media_info_get_uri (media_info));
g_print ("Duration: %" GST_TIME_FORMAT "\n",
GST_TIME_ARGS (gst_player_media_info_get_duration (media_info)));
g_print ("Global taglist:\n");
if (gst_player_media_info_get_tags (media_info))
gst_tag_list_foreach (gst_player_media_info_get_tags (media_info),
print_one_tag, NULL);
else
g_print (" (nil) \n");
list = gst_player_media_info_get_stream_list (media_info);
if (!list)
return;
g_print ("All Stream information\n");
for (l = list; l != NULL; l = l->next) {
GstTagList *tags = NULL;
GstPlayerStreamInfo *stream = (GstPlayerStreamInfo *) l->data;
g_print (" Stream # %u \n", count++);
g_print (" type : %s_%u\n",
gst_player_stream_info_get_stream_type (stream),
gst_player_stream_info_get_index (stream));
tags = gst_player_stream_info_get_tags (stream);
g_print (" taglist : \n");
if (tags) {
gst_tag_list_foreach (tags, print_one_tag, NULL);
}
if (GST_IS_PLAYER_VIDEO_INFO (stream))
print_video_info ((GstPlayerVideoInfo *) stream);
else if (GST_IS_PLAYER_AUDIO_INFO (stream))
print_audio_info ((GstPlayerAudioInfo *) stream);
else
print_subtitle_info ((GstPlayerSubtitleInfo *) stream);
}
}
static guint
tag_list_length (const GstTagList * tag_list)
{
guint len = 0;
if (tag_list == NULL)
return 0;
gst_tag_list_foreach (tag_list, (GstTagForeachFunc) tag_list_foreach, &len);
return len;
}
/**
* gst_tag_list_to_xmp_buffer:
* @list: tags
* @read_only: does the container forbid inplace editing
*
* Formats a taglist as a xmp packet.
*
* Returns: new buffer or %NULL, unref the buffer when done
*
* Since: 0.10.29
*/
GstBuffer *
gst_tag_list_to_xmp_buffer (const GstTagList * list, gboolean read_only)
{
GstBuffer *buffer = NULL;
GString *data = g_string_sized_new (4096);
guint i;
xmp_tags_initialize ();
g_return_val_if_fail (GST_IS_TAG_LIST (list), NULL);
/* xmp header */
g_string_append (data,
"<?xpacket begin=\"\xEF\xBB\xBF\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>\n");
g_string_append (data,
"<x:xmpmeta xmlns:x=\"adobe:ns:meta/\" x:xmptk=\"GStreamer\">\n");
g_string_append (data,
"<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"");
i = 0;
while (ns_match[i].ns_prefix) {
g_string_append_printf (data, " xmlns:%s=\"%s\"", ns_match[i].ns_prefix,
ns_match[i].ns_uri);
i++;
}
g_string_append (data, ">\n");
g_string_append (data, "<rdf:Description rdf:about=\"\">\n");
/* iterate the taglist */
gst_tag_list_foreach (list, write_one_tag, data);
/* xmp footer */
g_string_append (data, "</rdf:Description>\n");
g_string_append (data, "</rdf:RDF>\n");
g_string_append (data, "</x:xmpmeta>\n");
if (!read_only) {
/* the xmp spec recommand to add 2-4KB padding for in-place editable xmp */
guint i;
for (i = 0; i < 32; i++) {
g_string_append (data, " " " "
" " " " "\n");
}
}
g_string_append_printf (data, "<?xpacket end=\"%c\"?>\n",
(read_only ? 'r' : 'w'));
buffer = gst_buffer_new ();
GST_BUFFER_SIZE (buffer) = data->len + 1;
GST_BUFFER_DATA (buffer) = (guint8 *) g_string_free (data, FALSE);
GST_BUFFER_MALLOCDATA (buffer) = GST_BUFFER_DATA (buffer);
return buffer;
}
void
metadatamux_exif_create_chunk_from_tag_list (guint8 ** buf, guint32 * size,
const GstTagList * taglist, const MetaExifWriteOptions * opts)
{
ExifData *ed = NULL;
GstBuffer *exif_chunk = NULL;
const GValue *val = NULL;
if (!(buf && size))
goto done;
g_free (*buf);
*buf = NULL;
*size = 0;
val = gst_tag_list_get_value_index (taglist, GST_TAG_EXIF, 0);
if (val) {
exif_chunk = gst_value_get_buffer (val);
if (exif_chunk) {
ed = exif_data_new_from_data (GST_BUFFER_DATA (exif_chunk),
GST_BUFFER_SIZE (exif_chunk));
}
}
if (!ed) {
ed = exif_data_new ();
GST_DEBUG ("setting byteorder %d", opts->byteorder);
switch (opts->byteorder) {
case GST_META_EXIF_BYTE_ORDER_MOTOROLA:
exif_data_set_byte_order (ed, EXIF_BYTE_ORDER_MOTOROLA);
break;
case GST_META_EXIF_BYTE_ORDER_INTEL:
exif_data_set_byte_order (ed, EXIF_BYTE_ORDER_INTEL);
break;
default:
break;
}
exif_data_set_data_type (ed, EXIF_DATA_TYPE_COMPRESSED);
exif_data_fix (ed);
}
gst_tag_list_foreach (taglist, metadatamux_exif_for_each_tag_in_list, ed);
exif_data_save_data (ed, buf, size);
done:
if (ed)
exif_data_unref (ed);
return;
}
static guint
tag_setter_list_length (GstTagSetter * setter)
{
guint len = 0;
if (gst_tag_setter_get_tag_list (setter) == NULL)
return 0;
gst_tag_list_foreach (gst_tag_setter_get_tag_list (setter),
(GstTagForeachFunc) tag_list_foreach, &len);
return len;
}
static void
print_tags_topology (guint depth, const GstTagList * tags)
{
g_print ("%*sTags:\n", 2 * depth, " ");
if (tags) {
gst_tag_list_foreach (tags, print_tag_foreach,
GUINT_TO_POINTER (depth + 1));
} else {
g_print ("%*sNone\n", 2 * (depth + 1), " ");
}
if (verbose)
g_print ("%*s\n", 2 * depth, " ");
}
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;
}
/**
* Scan a single file
* @param file
* @return
*/
int scan_file (gchar * file) {
GstElement *pipe, *dec, *sink; /* Scanner pipeline */
GstMessage *msg; /* Scanner message buffer */
sqlite3 *database; /* SQL database */
gchar *zErrMsg = 0; /* SQL error message */
gint returnCode; /* SQL return code */
if (!gst_uri_is_valid (file))
g_error ("Must be used with a valid file uri.");
pipe = gst_pipeline_new ("pipeline");
dec = gst_element_factory_make ("uridecodebin", NULL);
g_object_set (dec, "uri", file, NULL);
gst_bin_add (GST_BIN (pipe), dec);
sink = gst_element_factory_make ("fakesink", NULL);
gst_bin_add (GST_BIN (pipe), sink);
g_signal_connect (dec, "pad-added", G_CALLBACK (on_new_pad), sink);
gst_element_set_state (pipe, GST_STATE_PAUSED);
while (TRUE) {
GstTagList *tags = NULL;
msg = gst_bus_timed_pop_filtered (GST_ELEMENT_BUS (pipe),
GST_CLOCK_TIME_NONE,
GST_MESSAGE_ASYNC_DONE | GST_MESSAGE_TAG | GST_MESSAGE_ERROR);
if (GST_MESSAGE_TYPE (msg) != GST_MESSAGE_TAG) /* error or async_done */
break;
gst_message_parse_tag (msg, &tags);
gst_tag_list_foreach (tags, insert_tags, NULL);
gst_tag_list_free (tags);
gst_message_unref (msg);
};
if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_ERROR)
g_error ("Got error");
gst_message_unref (msg);
gst_element_set_state (pipe, GST_STATE_NULL);
gst_object_unref (pipe);
return 0;
}
static gboolean gst_avdtp_sink_event(GstBaseSink *basesink,
GstEvent *event)
{
GstAvdtpSink *self = GST_AVDTP_SINK(basesink);
GstTagList *taglist = NULL;
if (GST_EVENT_TYPE(event) == GST_EVENT_TAG) {
/* we check the tags, mp3 has tags that are importants and
* are outside caps */
gst_event_parse_tag(event, &taglist);
gst_tag_list_foreach(taglist, gst_avdtp_sink_tag, self);
}
return TRUE;
}
/* Validate captured files by playing them with playbin
* and checking that no errors occur. */
static gboolean
check_file_validity (const gchar * filename, gint num, GstTagList * taglist)
{
GstBus *bus;
GMainLoop *loop = g_main_loop_new (NULL, FALSE);
GstElement *playbin = gst_element_factory_make ("playbin2", NULL);
GstElement *fakevideo = gst_element_factory_make ("fakesink", NULL);
GstElement *fakeaudio = gst_element_factory_make ("fakesink", NULL);
gchar *uri = g_strconcat ("file://", make_test_file_name (filename, num),
NULL);
GST_DEBUG ("checking uri: %s", uri);
g_object_set (G_OBJECT (playbin), "uri", uri, "video-sink", fakevideo,
"audio-sink", fakeaudio, NULL);
validation_taglist = NULL;
bus = gst_pipeline_get_bus (GST_PIPELINE (playbin));
gst_bus_add_watch (bus, (GstBusFunc) validity_bus_cb, loop);
gst_element_set_state (playbin, GST_STATE_PLAYING);
g_main_loop_run (loop);
gst_element_set_state (playbin, GST_STATE_NULL);
/* special handling for images (jpg) as jpegparse isn't plugged by
* default due to its current low rank */
if (taglist && strstr (filename, "image")) {
extract_jpeg_tags (filename, num);
}
/* check taglist */
if (taglist) {
fail_if (validation_taglist == NULL);
GST_DEBUG ("Comparing taglists %" GST_PTR_FORMAT "; with %" GST_PTR_FORMAT,
taglist, validation_taglist);
gst_tag_list_foreach (taglist, validate_taglist_foreach,
validation_taglist);
}
if (validation_taglist)
gst_tag_list_free (validation_taglist);
g_free (uri);
gst_object_unref (bus);
gst_object_unref (playbin);
return TRUE;
}
static void loading_messages(GstBus * bus,GstMessage * message,TPMediaPlayer * mp)
{
USERDATA(mp);
switch(message->type)
{
//.....................................................................
// When a tag is found
case GST_MESSAGE_TAG:
{
GstTagList * tags=NULL;
gst_message_parse_tag(message,&tags);
if (tags)
{
gst_tag_list_foreach(tags,collect_tags,mp);
gst_tag_list_free(tags);
}
break;
}
//.....................................................................
// When the load is done - the stream is paused and ready to go
case GST_MESSAGE_ASYNC_DONE:
{
get_stream_information(mp);
// Now, notify that the stream is loaded
tp_media_player_loaded(mp);
// Disconnect this signal handler
g_signal_handler_disconnect(bus,ud->load_signal);
ud->load_signal=0;
break;
}
default:
{
// Default handler to make clang shut up
break;
}
}
}
static gboolean
bbd_pipeline_bus_callback (GstBus *bus, GstMessage *message, gpointer data)
{
BansheeBpmDetector *detector = (BansheeBpmDetector *)data;
g_return_val_if_fail (detector != NULL, FALSE);
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_TAG: {
GstTagList *tags;
gst_message_parse_tag (message, &tags);
if (GST_IS_TAG_LIST (tags)) {
gst_tag_list_foreach (tags, (GstTagForeachFunc)bbd_pipeline_process_tag, detector);
gst_tag_list_free (tags);
}
break;
}
case GST_MESSAGE_ERROR: {
GError *error;
gchar *debug;
gst_message_parse_error (message, &error, &debug);
bbd_raise_error (detector, error->message, debug);
g_error_free (error);
g_free (debug);
detector->is_detecting = FALSE;
break;
}
case GST_MESSAGE_EOS: {
detector->is_detecting = FALSE;
gst_element_set_state (GST_ELEMENT (detector->pipeline), GST_STATE_NULL);
if (detector->finished_cb != NULL) {
detector->finished_cb ();
}
break;
}
default: break;
}
return TRUE;
}
void GstPlayer::parseMessage(GstMessage *msg){
switch (GST_MESSAGE_TYPE(msg)) {
case GST_MESSAGE_STATE_CHANGED: {
this->handleStateChangeMessage(msg);
break;
}
case GST_MESSAGE_DURATION:
this->queryDuration();
break;
case GST_MESSAGE_TAG: {
//QLOG_TRACE() << "[GST]" << GST_MESSAGE_TYPE_NAME(msg);
GstTagList * tagList;
// We should merge & store the list each time we get a new tag
// We should also send a signal for every new tag that is defined
gst_message_parse_tag(msg,&tagList);
gst_tag_list_foreach(tagList,handleGstTag,this->track);
gst_tag_list_free(tagList);
break;
}
case GST_MESSAGE_EOS: {
QLOG_TRACE() << "[GST] End-of-stream";
this->requestStop();
//g_main_loop_quit(loop);
break;
}
case GST_MESSAGE_ERROR: {
GError *err;
gst_message_parse_error(msg, &err, NULL);
QLOG_TRACE() << "[GST] [ERROR] " << err->message;
error = true;
g_error_free(err);
// TODO: handle some errors
// - Resource not found
//
// g_main_loop_quit(loop);
break;
}
default:
//QLOG_TRACE() << "[GST]" << GST_MESSAGE_TYPE_NAME(msg);
break;
}
}
bool ParseTagMessage (GstMessage *msg, TagMap_t& map, const QString& region)
{
GstTagList *tagList = nullptr;
gst_message_parse_tag (msg, &tagList);
if (!tagList)
return false;
TagFunctionData data { map, region };
gst_tag_list_foreach (tagList,
TagFunction,
&data);
#if GST_VERSION_MAJOR < 1
gst_tag_list_free (tagList);
#else
gst_tag_list_unref (tagList);
#endif
return true;
}
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 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
bus_call (GstBus *bus,
GstMessage *msg,
gpointer data)
{
GMainLoop *loop = (GMainLoop *) data;
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_EOS:
g_print ("end-of-stream\n");
break;
case GST_MESSAGE_ERROR: {
gchar *debug;
GError *error;
gst_message_parse_error (msg, &error, &debug);
g_free (debug);
g_printerr ("Error: %s\n", error->message);
g_error_free (error);
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_TAG: {
GstTagList *tags = NULL;
gst_message_parse_tag (msg, &tags);
gst_tag_list_foreach(tags,print_one_tag,NULL);
gst_tag_list_free(tags);
break;
}
default:
break;
};
return TRUE;
}
static gboolean
brasero_normalize_bus_messages (GstBus *bus,
GstMessage *msg,
BraseroNormalize *normalize)
{
GstTagList *tags = NULL;
GError *error = NULL;
gchar *debug;
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_TAG:
/* This is the information we've been waiting for.
* NOTE: levels for whole album is delivered at the end */
gst_message_parse_tag (msg, &tags);
gst_tag_list_foreach (tags, (GstTagForeachFunc) foreach_tag, normalize);
gst_tag_list_free (tags);
return TRUE;
case GST_MESSAGE_ERROR:
gst_message_parse_error (msg, &error, &debug);
BRASERO_JOB_LOG (normalize, debug);
g_free (debug);
brasero_job_error (BRASERO_JOB (normalize), error);
return FALSE;
case GST_MESSAGE_EOS:
brasero_normalize_song_end_reached (normalize);
return FALSE;
case GST_MESSAGE_STATE_CHANGED:
break;
default:
return TRUE;
}
return TRUE;
}
static gboolean
actually_emit_stream_and_tags (RBPlayerGst *player)
{
GList *t;
_rb_player_emit_playing_stream (RB_PLAYER (player), player->priv->stream_data);
/* process any tag lists we received while starting the stream */
for (t = player->priv->stream_tags; t != NULL; t = t->next) {
GstTagList *tags;
tags = (GstTagList *)t->data;
rb_debug ("processing buffered taglist");
gst_tag_list_foreach (tags, (GstTagForeachFunc) process_tag, player);
gst_tag_list_free (tags);
}
g_list_free (player->priv->stream_tags);
player->priv->stream_tags = NULL;
player->priv->emit_stream_idle_id = 0;
return FALSE;
}
static void
print_properties (GstDiscovererInfo * info, gint tab)
{
const GstTagList *tags;
const GstToc *toc;
g_print ("%*sDuration: %" GST_TIME_FORMAT "\n", tab + 1, " ",
GST_TIME_ARGS (gst_discoverer_info_get_duration (info)));
g_print ("%*sSeekable: %s\n", tab + 1, " ",
(gst_discoverer_info_get_seekable (info) ? "yes" : "no"));
if ((tags = gst_discoverer_info_get_tags (info))) {
g_print ("%*sTags: \n", tab + 1, " ");
gst_tag_list_foreach (tags, print_tag_foreach, GUINT_TO_POINTER (tab + 2));
}
if (show_toc && (toc = gst_discoverer_info_get_toc (info))) {
GList *entries;
g_print ("%*sTOC: \n", tab + 1, " ");
entries = gst_toc_get_entries (toc);
g_list_foreach (entries, print_toc_entry, GUINT_TO_POINTER (tab + 5));
}
}
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);
}
}
void QGstreamerPlayerSession::busMessage(const QGstreamerMessage &message)
{
GstMessage* gm = message.rawMessage();
if (gm == 0) {
// Null message, query current position
quint32 newPos = position();
if (newPos/1000 != m_lastPosition) {
m_lastPosition = newPos/1000;
emit positionChanged(newPos);
}
double volume = 1.0;
g_object_get(G_OBJECT(m_playbin), "volume", &volume, NULL);
if (m_volume != int(volume*100)) {
m_volume = int(volume*100);
emit volumeChanged(m_volume);
}
} else {
//tag message comes from elements inside playbin, not from playbin itself
if (GST_MESSAGE_TYPE(gm) == GST_MESSAGE_TAG) {
//qDebug() << "tag message";
GstTagList *tag_list;
gst_message_parse_tag(gm, &tag_list);
gst_tag_list_foreach(tag_list, addTagToMap, &m_tags);
//qDebug() << m_tags;
emit tagsChanged();
}
if (GST_MESSAGE_SRC(gm) == GST_OBJECT_CAST(m_playbin)) {
switch (GST_MESSAGE_TYPE(gm)) {
case GST_MESSAGE_STATE_CHANGED:
{
GstState oldState;
GstState newState;
GstState pending;
gst_message_parse_state_changed(gm, &oldState, &newState, &pending);
#ifdef DEBUG_PLAYBIN
QStringList states;
states << "GST_STATE_VOID_PENDING" << "GST_STATE_NULL" << "GST_STATE_READY" << "GST_STATE_PAUSED" << "GST_STATE_PLAYING";
qDebug() << QString("state changed: old: %1 new: %2 pending: %3") \
.arg(states[oldState]) \
.arg(states[newState]) \
.arg(states[pending]);
#endif
switch (newState) {
case GST_STATE_VOID_PENDING:
case GST_STATE_NULL:
setSeekable(false);
finishVideoOutputChange();
if (m_state != QMediaPlayer::StoppedState)
emit stateChanged(m_state = QMediaPlayer::StoppedState);
break;
case GST_STATE_READY:
setSeekable(false);
if (m_state != QMediaPlayer::StoppedState)
emit stateChanged(m_state = QMediaPlayer::StoppedState);
break;
case GST_STATE_PAUSED:
{
QMediaPlayer::State prevState = m_state;
m_state = QMediaPlayer::PausedState;
//check for seekable
if (oldState == GST_STATE_READY) {
getStreamsInfo();
updateVideoResolutionTag();
/*
//gst_element_seek_simple doesn't work reliably here, have to find a better solution
GstFormat format = GST_FORMAT_TIME;
gint64 position = 0;
bool seekable = false;
if (gst_element_query_position(m_playbin, &format, &position)) {
seekable = gst_element_seek_simple(m_playbin, format, GST_SEEK_FLAG_NONE, position);
}
setSeekable(seekable);
*/
setSeekable(true);
if (!qFuzzyCompare(m_playbackRate, qreal(1.0))) {
qreal rate = m_playbackRate;
m_playbackRate = 1.0;
setPlaybackRate(rate);
}
}
if (m_state != prevState)
emit stateChanged(m_state);
break;
}
case GST_STATE_PLAYING:
if (m_state != QMediaPlayer::PlayingState)
emit stateChanged(m_state = QMediaPlayer::PlayingState);
break;
}
}
break;
case GST_MESSAGE_EOS:
emit playbackFinished();
break;
case GST_MESSAGE_TAG:
case GST_MESSAGE_STREAM_STATUS:
case GST_MESSAGE_UNKNOWN:
break;
case GST_MESSAGE_ERROR:
{
GError *err;
gchar *debug;
gst_message_parse_error (gm, &err, &debug);
emit error(int(QMediaPlayer::ResourceError), QString::fromUtf8(err->message));
qWarning() << "Error:" << QString::fromUtf8(err->message);
g_error_free (err);
g_free (debug);
}
break;
case GST_MESSAGE_WARNING:
{
GError *err;
gchar *debug;
gst_message_parse_warning (gm, &err, &debug);
qWarning() << "Warning:" << QString::fromUtf8(err->message);
g_error_free (err);
g_free (debug);
}
break;
case GST_MESSAGE_INFO:
#ifdef DEBUG_PLAYBIN
{
GError *err;
gchar *debug;
gst_message_parse_info (gm, &err, &debug);
qDebug() << "Info:" << QString::fromUtf8(err->message);
g_error_free (err);
g_free (debug);
}
#endif
break;
case GST_MESSAGE_BUFFERING:
{
int progress = 0;
gst_message_parse_buffering(gm, &progress);
emit bufferingProgressChanged(progress);
}
break;
case GST_MESSAGE_STATE_DIRTY:
case GST_MESSAGE_STEP_DONE:
case GST_MESSAGE_CLOCK_PROVIDE:
case GST_MESSAGE_CLOCK_LOST:
case GST_MESSAGE_NEW_CLOCK:
case GST_MESSAGE_STRUCTURE_CHANGE:
case GST_MESSAGE_APPLICATION:
case GST_MESSAGE_ELEMENT:
break;
case GST_MESSAGE_SEGMENT_START:
{
const GstStructure *structure = gst_message_get_structure(gm);
qint64 position = g_value_get_int64(gst_structure_get_value(structure, "position"));
position /= 1000000;
m_lastPosition = position;
emit positionChanged(position);
}
break;
case GST_MESSAGE_SEGMENT_DONE:
break;
case GST_MESSAGE_DURATION:
{
GstFormat format = GST_FORMAT_TIME;
gint64 duration = 0;
if (gst_element_query_duration(m_playbin, &format, &duration)) {
int newDuration = duration / 1000000;
if (m_duration != newDuration) {
m_duration = newDuration;
emit durationChanged(m_duration);
}
}
}
break;
case GST_MESSAGE_LATENCY:
#if (GST_VERSION_MAJOR >= 0) && (GST_VERSION_MINOR >= 10) && (GST_VERSION_MICRO >= 13)
case GST_MESSAGE_ASYNC_START:
case GST_MESSAGE_ASYNC_DONE:
#if GST_VERSION_MICRO >= 23
case GST_MESSAGE_REQUEST_STATE:
#endif
#endif
case GST_MESSAGE_ANY:
break;
default:
break;
}
} else if (m_videoSink
&& m_renderer
&& GST_MESSAGE_SRC(gm) == GST_OBJECT_CAST(m_videoSink)
&& GST_MESSAGE_TYPE(gm) == GST_MESSAGE_STATE_CHANGED) {
GstState oldState;
GstState newState;
gst_message_parse_state_changed(gm, &oldState, &newState, 0);
if (oldState == GST_STATE_READY && newState == GST_STATE_PAUSED)
m_renderer->precessNewStream();
}
}
}
static gboolean
handle_message (InsanityGstPipelineTest * ptest, GstMessage * message)
{
gboolean ret = FALSE, done = FALSE;
/* Allow the test code to handle the message instead */
g_signal_emit (ptest, bus_message_signal, 0, message, &ret);
if (!ret)
return FALSE;
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ERROR:{
GError *error = NULL;
char *debug = NULL;
gst_message_parse_error (message, &error, &debug);
send_error (ptest, error, debug);
insanity_test_printf (INSANITY_TEST (ptest), "Error (%s, %s), quitting\n",
error->message, debug);
g_error_free (error);
g_free (debug);
done = TRUE;
break;
}
case GST_MESSAGE_STATE_CHANGED:
if (GST_MESSAGE_SRC (message) == GST_OBJECT (ptest->priv->pipeline)) {
GstState oldstate, newstate, pending;
gst_message_parse_state_changed (message, &oldstate, &newstate,
&pending);
if (newstate >= GST_STATE_PAUSED) {
gint i;
for (i = 0; i < G_N_ELEMENTS (duration_query_formats); i++)
insanity_gst_pipeline_test_query_duration (ptest,
duration_query_formats[i], NULL);
}
if (newstate == ptest->priv->initial_state
&& pending == GST_STATE_VOID_PENDING
&& !ptest->priv->reached_initial_state) {
gboolean ret = TRUE;
ptest->priv->reached_initial_state = TRUE;
insanity_test_validate_checklist_item (INSANITY_TEST (ptest),
"reached-initial-state", TRUE, NULL);
/* Tell the test we reached our initial state */
g_signal_emit (ptest, reached_initial_state_signal, 0, &ret);
if (!ret) {
insanity_test_printf (INSANITY_TEST (ptest),
"Reached initial state, and asked to quit, quitting\n");
done = TRUE;
}
}
}
break;
case GST_MESSAGE_TAG:{
GstTagList *tags;
gst_message_parse_tag (message, &tags);
gst_tag_list_foreach (tags, &send_tag, (gpointer) ptest);
gst_tag_list_unref (tags);
break;
}
case GST_MESSAGE_DURATION_CHANGED:{
gint i;
for (i = 0; i < G_N_ELEMENTS (duration_query_formats); i++)
insanity_gst_pipeline_test_query_duration (ptest,
duration_query_formats[i], NULL);
break;
}
case GST_MESSAGE_EOS:
if (GST_MESSAGE_SRC (message) == GST_OBJECT (ptest->priv->pipeline)) {
/* Warning from the original Python source:
# it's not 100% sure we want to stop here, because of the
# race between the final state-change message and the eos message
# arriving on the bus.
*/
if (ptest->priv->reached_initial_state) {
insanity_test_printf (INSANITY_TEST (ptest),
"Got EOS from pipeline, and we reached initial state, quitting\n");
done = TRUE;
} else {
/* If we've not seen the state change to initial state yet, we give
an extra 3 seconds for it to complete */
insanity_test_printf (INSANITY_TEST (ptest),
"Got EOS from pipeline, and we did not reach initial state, delaying quit\n");
ptest->priv->wait_timeout_id =
g_timeout_add (3000, (GSourceFunc) & waiting_for_state_change,
ptest);
}
}
break;
case GST_MESSAGE_BUFFERING:{
gint percent;
gst_message_parse_buffering (message, &percent);
/* no state management needed for live pipelines */
if (ptest->priv->is_live || !ptest->priv->enable_buffering)
break;
if (percent == 100) {
/* a 100% message means buffering is done */
ptest->priv->buffering = FALSE;
/* if the desired state is playing, go back */
if (ptest->priv->initial_state == GST_STATE_PLAYING) {
gst_element_set_state (GST_ELEMENT (ptest->priv->pipeline),
GST_STATE_PLAYING);
}
} else {
/* buffering busy */
if (ptest->priv->buffering == FALSE
&& ptest->priv->initial_state == GST_STATE_PLAYING) {
/* we were not buffering but PLAYING, PAUSE the pipeline. */
gst_element_set_state (GST_ELEMENT (ptest->priv->pipeline),
GST_STATE_PAUSED);
}
ptest->priv->buffering = TRUE;
}
break;
case GST_MESSAGE_CLOCK_LOST:
gst_element_set_state (GST_ELEMENT (ptest->priv->pipeline),
GST_STATE_PAUSED);
gst_element_set_state (GST_ELEMENT (ptest->priv->pipeline),
GST_STATE_PLAYING);
break;
}
default:
break;
}
return done;
}
