/* 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; }