/* FIXME: Copy from owr/orw.c without any error handling whatsoever */
static gboolean bus_call(GstBus *bus, GstMessage *msg, gpointer user_data)
{
gboolean ret, is_warning = FALSE;
GstStateChangeReturn change_status;
gchar *message_type, *debug;
GError *error;
GstPipeline *pipeline = user_data;
g_return_val_if_fail(GST_IS_BUS(bus), TRUE);
(void)user_data;
switch (GST_MESSAGE_TYPE(msg)) {
case GST_MESSAGE_LATENCY:
ret = gst_bin_recalculate_latency(GST_BIN(pipeline));
g_warn_if_fail(ret);
break;
case GST_MESSAGE_CLOCK_LOST:
change_status = gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PAUSED);
g_warn_if_fail(change_status != GST_STATE_CHANGE_FAILURE);
change_status = gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PLAYING);
g_warn_if_fail(change_status != GST_STATE_CHANGE_FAILURE);
break;
case GST_MESSAGE_EOS:
g_print("End of stream\n");
break;
case GST_MESSAGE_WARNING:
is_warning = TRUE;
case GST_MESSAGE_ERROR:
if (is_warning) {
message_type = "Warning";
gst_message_parse_warning(msg, &error, &debug);
} else {
message_type = "Error";
gst_message_parse_error(msg, &error, &debug);
}
g_printerr("==== %s message start ====\n", message_type);
g_printerr("%s in element %s.\n", message_type, GST_OBJECT_NAME(msg->src));
g_printerr("%s: %s\n", message_type, error->message);
g_printerr("Debugging info: %s\n", (debug) ? debug : "none");
g_printerr("==== %s message stop ====\n", message_type);
/*GST_DEBUG_BIN_TO_DOT_FILE(GST_BIN(pipeline), GST_DEBUG_GRAPH_SHOW_ALL, "pipeline.dot");*/
g_error_free(error);
g_free(debug);
break;
default:
break;
}
return TRUE;
}
static void
event_loop (GstElement * pipe)
{
GstBus *bus;
GstMessage *message = NULL;
bus = gst_element_get_bus (GST_ELEMENT (pipe));
while (TRUE) {
message = gst_bus_timed_pop_filtered (bus, GST_MESSAGE_ANY, -1);
g_assert (message != NULL);
switch (message->type) {
case GST_MESSAGE_EOS:
g_message ("got EOS");
gst_message_unref (message);
return;
case GST_MESSAGE_WARNING:
case GST_MESSAGE_ERROR:
{
GError *gerror;
gchar *debug;
gst_message_parse_error (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
gst_message_unref (message);
g_error_free (gerror);
g_free (debug);
return;
}
case GST_MESSAGE_STEP_DONE:
{
GstFormat format;
guint64 amount;
gdouble rate;
gboolean flush, intermediate;
guint64 duration;
gboolean eos;
gst_message_parse_step_done (message, &format, &amount, &rate,
&flush, &intermediate, &duration, &eos);
if (format == GST_FORMAT_DEFAULT) {
g_message ("step done: %" GST_TIME_FORMAT " skipped in %"
G_GUINT64_FORMAT " frames", GST_TIME_ARGS (duration), amount);
} else {
g_message ("step done: %" GST_TIME_FORMAT " skipped",
GST_TIME_ARGS (duration));
}
return;
}
default:
gst_message_unref (message);
break;
}
}
}
void
sync_error_handler (GstBus *bus, GstMessage *message, gpointer blob)
{
GError *error = NULL;
gchar *debug;
gst_message_parse_error (message, &error, &debug);
g_error ("bus sync error %s", error->message);
}
static gboolean bus_watch_handler(GstBus *bus, GstMessage *msg, gpointer data)
{
struct ausrc_st *st = data;
GMainLoop *loop = st->loop;
GstTagList *tag_list;
gchar *title;
GError *err;
gchar *d;
(void)bus;
switch (GST_MESSAGE_TYPE(msg)) {
case GST_MESSAGE_EOS:
/* Re-start stream */
if (st->run) {
gst_element_set_state(st->pipeline, GST_STATE_NULL);
gst_element_set_state(st->pipeline, GST_STATE_PLAYING);
}
else {
g_main_loop_quit(loop);
}
break;
case GST_MESSAGE_ERROR:
gst_message_parse_error(msg, &err, &d);
warning("gst: Error: %d(%m) message=\"%s\"\n", err->code,
err->code, err->message);
warning("gst: Debug: %s\n", d);
g_free(d);
/* Call error handler */
if (st->errh)
st->errh(err->code, err->message, st->arg);
g_error_free(err);
st->run = false;
g_main_loop_quit(loop);
break;
case GST_MESSAGE_TAG:
gst_message_parse_tag(msg, &tag_list);
if (gst_tag_list_get_string(tag_list, GST_TAG_TITLE, &title)) {
info("gst: title: %s\n", title);
g_free(title);
}
break;
default:
break;
}
return TRUE;
}
static gboolean
gst_transcoder_bus_callback(GstBus *bus, GstMessage *message, gpointer data)
{
GstTranscoder *transcoder = (GstTranscoder *)data;
g_return_val_if_fail(transcoder != NULL, FALSE);
switch(GST_MESSAGE_TYPE(message)) {
case GST_MESSAGE_ERROR: {
GError *error;
gchar *debug;
transcoder->is_transcoding = FALSE;
gst_transcoder_stop_iterate_timeout(transcoder);
if(transcoder->error_cb != NULL) {
gst_message_parse_error(message, &error, &debug);
gst_transcoder_raise_error(transcoder, error->message, debug);
g_error_free(error);
g_free(debug);
}
break;
}
case GST_MESSAGE_EOS:
gst_element_set_state(GST_ELEMENT(transcoder->pipeline), GST_STATE_NULL);
g_object_unref(G_OBJECT(transcoder->pipeline));
transcoder->pipeline = NULL;
transcoder->is_transcoding = FALSE;
gst_transcoder_stop_iterate_timeout(transcoder);
/*
FIXME: Replace with regular stat
GnomeVFSFileInfo fileinfo;
if(gnome_vfs_get_file_info(transcoder->output_uri, &fileinfo,
GNOME_VFS_FILE_INFO_DEFAULT) == GNOME_VFS_OK) {
if(fileinfo.size < 100) {
gst_transcoder_raise_error(transcoder,
_("No decoder could be found for source format."), NULL);
g_remove(transcoder->output_uri);
break;
}
} else {
gst_transcoder_raise_error(transcoder, _("Could not stat encoded file"), NULL);
break;
}*/
if(transcoder->finished_cb != NULL) {
transcoder->finished_cb(transcoder);
}
break;
default:
break;
}
return TRUE;
}
static void get_device_data (ofGstDevice &webcam_device, int desired_framerate)
{
string pipeline_desc = webcam_device.gstreamer_src + " name=source device=" +
webcam_device.video_device + " ! fakesink";
GError * err = NULL;
GstElement * pipeline = gst_parse_launch (pipeline_desc.c_str(), &err);
if ((pipeline == NULL) || (err != NULL)){
if (err){
ofLog(OF_LOG_ERROR, "ofGstUtils: error getting device data: %s", err->message);
g_error_free (err);
}else{
ofLog(OF_LOG_ERROR, "ofGstUtils: error getting device data, cannot get pipeline");
}
if(pipeline)
gst_object_unref (pipeline);
return;
}
// TODO: try to lower seconds,
// Start the pipeline and wait for max. 10 seconds for it to start up
gst_element_set_state (pipeline, GST_STATE_PLAYING);
GstStateChangeReturn ret = gst_element_get_state (pipeline, NULL, NULL, 10 * GST_SECOND);
// Check if any error messages were posted on the bus
GstBus * bus = gst_element_get_bus (pipeline);
GstMessage * msg = gst_bus_poll (bus, GST_MESSAGE_ERROR, 0);
gst_object_unref (bus);
if ((msg == NULL) && (ret == GST_STATE_CHANGE_SUCCESS)){
gst_element_set_state (pipeline, GST_STATE_PAUSED);
GstElement *src = gst_bin_get_by_name (GST_BIN (pipeline), "source");
char *name;
g_object_get (G_OBJECT (src), "device-name", &name, (void*)NULL);
ofLog(OF_LOG_VERBOSE, "Device: %s (%s)\n", name==NULL?"":name, webcam_device.video_device.c_str());
GstPad *pad = gst_element_get_pad (src, "src");
GstCaps *caps = gst_pad_get_caps (pad);
gst_object_unref (pad);
get_supported_video_formats (webcam_device, *caps, desired_framerate);
gst_caps_unref (caps);
}else if(msg){
gchar *debug;
gst_message_parse_error(msg, &err, &debug);
ofLog(OF_LOG_ERROR, "ofGstUtils: error getting device data; module %s reported: %s",
gst_element_get_name(GST_MESSAGE_SRC (msg)), err->message);
g_error_free(err);
g_free(debug);
}
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
}
static gboolean
message_handler (GstBus * bus, GstMessage * message, gpointer user_data)
{
switch (GST_MESSAGE_TYPE (message)) {
#ifdef ASYNC_VERSION
case GST_MESSAGE_ELEMENT:{
const GstStructure *str;
str = gst_message_get_structure (message);
if (gst_structure_has_name (str, "GstBinForwarded")) {
GstMessage *orig;
/* unwrap the element message */
gst_structure_get (str, "message", GST_TYPE_MESSAGE, &orig, NULL);
g_assert (orig);
switch (GST_MESSAGE_TYPE (orig)) {
case GST_MESSAGE_ASYNC_DONE:
g_print ("ASYNC done %s\n", GST_MESSAGE_SRC_NAME (orig));
if (GST_MESSAGE_SRC (orig) == GST_OBJECT_CAST (play_bin)) {
g_print
("prerolled, starting synchronized playback and recording\n");
/* returns ASYNC because the sink linked to the live source is not
* prerolled */
g_assert (gst_element_set_state (pipeline,
GST_STATE_PLAYING) == GST_STATE_CHANGE_ASYNC);
}
break;
default:
break;
}
}
break;
}
#endif
case GST_MESSAGE_EOS:
g_print ("EOS\n");
g_main_loop_quit (loop);
break;
case GST_MESSAGE_ERROR:{
GError *err = NULL;
gst_message_parse_error (message, &err, NULL);
g_print ("error: %s\n", err->message);
g_clear_error (&err);
g_main_loop_quit (loop);
break;
}
default:
break;
}
return TRUE;
}
static gboolean bus_call (GstBus *bus, GstMessage *msg, gpointer data)
{
GMainLoop *loop = (GMainLoop *) data;
switch (GST_MESSAGE_TYPE (msg))
{
case GST_MESSAGE_APPLICATION:
{
const GstStructure * msg_struct = gst_message_get_structure(msg);
guint64 duration = 0;
guint64 timestamp = 0;
int stream_thread_id = 0;
g_debug("APPLICATION CUSTOM MESSAGE !!!");
g_debug("MESSAGE THREAD ID[%p]", g_thread_self());
gst_structure_get_clock_time (msg_struct, "duration" , &duration);
gst_structure_get_clock_time (msg_struct, "timestamp" , ×tamp);
gst_structure_get_int (msg_struct, "stream_thread_id" , &stream_thread_id);
g_debug("STREAM THREAD ID[0x%x]", stream_thread_id);
g_debug("DURATION[%llu], TIMESTAMP[%llu]", duration, timestamp);
g_debug("Testing string message, [%s]\n", gst_structure_get_string(msg_struct, "msg"));
break;
}
case GST_MESSAGE_EOS:
{
g_print ("End of stream\n");
g_main_loop_quit (loop);
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;
}
default:
g_print("Msg type [%d], Msg name [%s]\n", GST_MESSAGE_TYPE (msg), GST_MESSAGE_TYPE_NAME(msg));
break;
} return TRUE;
}
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 GstBusSyncReply
_bus_sync_handler (GstBus * bus, GstMessage * message, gpointer data)
{
if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR) {
fail_unless (gerror == NULL && error_debug == NULL);
fail_unless (GST_MESSAGE_SRC (message) == GST_OBJECT (demux));
gst_message_parse_error (message, &gerror, &error_debug);
}
return GST_BUS_PASS;
}
static gboolean
bus_callback (GstBus * bus, GstMessage * message, gpointer data)
{
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_WARNING:{
GError *err;
gchar *debug;
gst_message_parse_warning (message, &err, &debug);
g_print ("Warning: %s\n", err->message);
g_error_free (err);
g_free (debug);
break;
}
case GST_MESSAGE_ERROR:{
GError *err;
gchar *debug = NULL;
gst_message_parse_error (message, &err, &debug);
g_print ("Error: %s : %s\n", err->message, debug);
g_error_free (err);
g_free (debug);
gtk_main_quit ();
break;
}
case GST_MESSAGE_TAG:{
GstTagList *tags;
GValue v = { 0, };
g_print ("Got tags\n");
gst_message_parse_tag (message, &tags);
if (gst_tag_list_copy_value (&v, tags, "mxf-structure")) {
const GstStructure *s;
GtkTreeIter iter;
s = gst_value_get_structure (&v);
gtk_tree_store_append (treestore, &iter, NULL);
insert_structure (s, &iter);
gtk_widget_show_all (window);
g_value_unset (&v);
}
gst_tag_list_unref (tags);
break;
}
default:
break;
}
return TRUE;
}
static gboolean
bus_handler (GstBus * bus, GstMessage * message, gpointer data)
{
GMainLoop *loop = (GMainLoop *) data;
switch (message->type) {
case GST_MESSAGE_EOS:
g_main_loop_quit (loop);
break;
case GST_MESSAGE_WARNING:
case GST_MESSAGE_ERROR:{
GError *gerror;
gchar *debug;
if (message->type == GST_MESSAGE_WARNING)
gst_message_parse_warning (message, &gerror, &debug);
else
gst_message_parse_error (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
gst_message_unref (message);
g_error_free (gerror);
g_free (debug);
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_TAG:
{
GstTagList *tag_list;
gchar *fpr, *p;
gst_message_parse_tag (message, &tag_list);
fail_unless (gst_tag_list_get_string (tag_list, "ofa-fingerprint", &fpr));
p = fpr;
while (*p) {
fail_unless (g_ascii_isalnum (*p) || *p == '=' || *p == '+'
|| *p == '/');
p++;
}
g_free (fpr);
gst_tag_list_unref (tag_list);
found_fingerprint = TRUE;
g_main_loop_quit (loop);
break;
}
default:
break;
}
return TRUE;
}
static gboolean bus_call (GstBus *bus,GstMessage *msg, gpointer data) {
if (gst_is_video_overlay_prepare_window_handle_message (msg)) {
if (0 != g_video_xid) {
GstVideoOverlay *overlay;
// GST_MESSAGE_SRC (message) will be the video sink element
overlay = GST_VIDEO_OVERLAY (GST_MESSAGE_SRC (msg));
gst_video_overlay_set_window_handle (overlay, g_video_xid);
} else {
g_warning ("Should have obtained video_window_handle by now!");
}
}
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_EOS:
g_print ("####################### Stream Ends\n");
gtk_main_quit();
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);
gtk_main_quit();
break;
}
case GST_MESSAGE_STATE_CHANGED: {
GstState oldState;
GstState newState;
GstState pendingState;
gst_message_parse_state_changed(msg, &oldState, &newState, &pendingState);
g_printf("####################### oldState:%d, newState:%d, pendingState:%d!\n", oldState, newState, pendingState);
break;
}
case GST_MESSAGE_STREAM_STATUS: {
GstStreamStatusType statusType;
GstElement* owner = NULL;
gst_message_parse_stream_status(msg, &statusType, &owner);
g_printf("####################### statusType:%d, owner:%p!\n", statusType, owner);
break;
}
default:
break;
}
return TRUE;
}
void GStreamerBaseFrameSourceImpl::handleGStreamerMessages()
{
GstMessage* msg = NULL;
GError *err = NULL;
gchar *debug = NULL;
GstStreamStatusType tp;
GstElement * elem = NULL;
if (!bus)
return;
while (gst_bus_have_pending(bus))
{
msg = gst_bus_pop(bus);
if (gst_is_missing_plugin_message(msg))
{
printf("GStreamer: your gstreamer installation is missing a required plugin!\n");
end = true;
}
else
{
switch (GST_MESSAGE_TYPE(msg))
{
case GST_MESSAGE_STATE_CHANGED:
GstState oldstate, newstate, pendstate;
gst_message_parse_state_changed(msg, &oldstate, &newstate, &pendstate);
break;
case GST_MESSAGE_ERROR:
{
gst_message_parse_error(msg, &err, &debug);
std::unique_ptr<char[], GlibDeleter> name(gst_element_get_name(GST_MESSAGE_SRC (msg)));
printf("GStreamer Plugin: Embedded video playback halted; module %s reported: %s\n",
name.get(), err->message);
g_error_free(err);
g_free(debug);
end = true;
break;
}
case GST_MESSAGE_EOS:
end = true;
break;
case GST_MESSAGE_STREAM_STATUS:
gst_message_parse_stream_status(msg,&tp,&elem);
break;
default:
break;
}
}
gst_message_unref(msg);
}
}
static bool default_msg_handler( decoder_t *p_dec, GstMessage *p_msg )
{
bool err = false;
switch( GST_MESSAGE_TYPE( p_msg ) ){
case GST_MESSAGE_ERROR:
{
gchar *psz_debug;
GError *p_error;
gst_message_parse_error( p_msg, &p_error, &psz_debug );
g_free( psz_debug );
msg_Err( p_dec, "Error from %s: %s",
GST_ELEMENT_NAME( GST_MESSAGE_SRC( p_msg ) ),
p_error->message );
g_error_free( p_error );
err = true;
}
break;
case GST_MESSAGE_WARNING:
{
gchar *psz_debug;
GError *p_error;
gst_message_parse_warning( p_msg, &p_error, &psz_debug );
g_free( psz_debug );
msg_Warn( p_dec, "Warning from %s: %s",
GST_ELEMENT_NAME( GST_MESSAGE_SRC( p_msg ) ),
p_error->message );
g_error_free( p_error );
}
break;
case GST_MESSAGE_INFO:
{
gchar *psz_debug;
GError *p_error;
gst_message_parse_info( p_msg, &p_error, &psz_debug );
g_free( psz_debug );
msg_Info( p_dec, "Info from %s: %s",
GST_ELEMENT_NAME( GST_MESSAGE_SRC( p_msg ) ),
p_error->message );
g_error_free( p_error );
}
break;
default:
break;
}
return err;
}
static gboolean app_bus_callback(GstBus *bus, GstMessage *message, gpointer data)
{
app_data_t *app = data;
GMainLoop *loop = app->loop;
switch (GST_MESSAGE_TYPE(message))
{
case GST_MESSAGE_ERROR:
{
GError *err;
gchar *debug;
/* ...dump error-message reported by the GStreamer */
gst_message_parse_error (message, &err, &debug);
TRACE(ERROR, _b("execution failed: %s"), err->message);
g_error_free(err);
g_free(debug);
/* ...right now this is a fatal error */
BUG(1, _x("breakpoint"));
/* ...and terminate the loop */
g_main_loop_quit(loop);
break;
}
case GST_MESSAGE_EOS:
{
/* ...end-of-stream encountered; break the loop */
TRACE(INFO, _b("execution completed"));
g_main_loop_quit(loop);
break;
}
case GST_MESSAGE_STATE_CHANGED:
{
/* ...state has changed; test if it is start or stop */
if (GST_MESSAGE_SRC(message) == GST_OBJECT_CAST(app->pipe))
{
GstState old, new, pending;
/* ...parse state message */
gst_message_parse_state_changed(message, &old, &new, &pending);
TRACE(INFO, _b("transition from %d to %d"), old, new);
}
break;
}
default:
/* ...ignore message */
TRACE(0, _b("ignore message: %s"), gst_message_type_get_name(GST_MESSAGE_TYPE(message)));
}
QString ErrorMessage::debugMessage() const
{
gchar *debug;
GError *e;
//Passing a NULL pointer for the GError is not supported
gst_message_parse_error(object<GstMessage>(), &e, &debug);
if (e) {
g_error_free (e);
}
return QGlib::Private::stringFromGCharPtr(debug);
}
static VALUE
error_parse(VALUE self)
{
VALUE result;
GError *error;
gchar *debug;
gst_message_parse_error(SELF(self), &error, &debug);
result = rb_ary_new3(2, GERROR2RVAL(error), CSTR2RVAL_FREE(debug));
return result;
}
static void internal_bus_watch_handler(struct gst_video_state *st)
{
GstTagList *tag_list;
gchar *title;
GError *err;
gchar *d;
GstMessage *msg = gst_bus_pop(st->bus);
if (!msg) {
// take a nap (300ms)
usleep(300 * 1000);
return;
}
switch (GST_MESSAGE_TYPE(msg)) {
case GST_MESSAGE_EOS:
/* XXX decrementing repeat count? */
/* Re-start stream */
gst_element_set_state(st->pipeline, GST_STATE_NULL);
gst_element_set_state(st->pipeline, GST_STATE_PLAYING);
break;
case GST_MESSAGE_ERROR:
gst_message_parse_error(msg, &err, &d);
DEBUG_WARNING("Error: %d(%m) message=%s\n", err->code,
err->code, err->message);
DEBUG_WARNING("Debug: %s\n", d);
g_free(d);
g_error_free(err);
st->run = FALSE;
break;
case GST_MESSAGE_TAG:
gst_message_parse_tag(msg, &tag_list);
if (gst_tag_list_get_string(tag_list, GST_TAG_TITLE, &title)) {
DEBUG_NOTICE("Title: %s\n", title);
g_free(title);
}
break;
default:
break;
}
gst_message_unref(msg);
}
/**
* GST bus signal watch callback
*/
void Pipeline::end_stream_cb(GstBus* /*bus*/, GstMessage* message, gpointer user_data)
{
Pipeline *context = static_cast<Pipeline*>(user_data);
bool is_verbose = context->owner_->get_configuration()->get_verbose();
if (is_verbose)
std::cout << "Pipeline::" << __FUNCTION__ << "(" << message << ")" << std::endl;
bool stop_it = true;
if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR)
{
gchar *debug = NULL;
GError *err = NULL;
gst_message_parse_error(message, &err, &debug);
g_printerr("GStreamer ERROR from element %s: %s\n", GST_OBJECT_NAME(message->src), err->message);
show_unlinked_pads(GST_BIN(context->pipeline_));
//if (message->src == GST_OBJECT(context->videosrc_))
//{
// g_print("The error message comes from %s. Not stopping the pipeline.\n", GST_OBJECT_NAME(message->src));
// stop_it = false;
//}
g_error_free(err);
if (debug)
{
g_print("Error message Debug details: %s\n", debug);
g_free(debug);
}
}
else if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_EOS)
{
std::cout << "EOS: End of stream" << std::endl;
}
else if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_WARNING)
{
gchar *debug = NULL;
GError *err = NULL;
gst_message_parse_warning(message, &err, &debug);
g_print("Warning: %s\n", err->message);
g_error_free(err);
if (debug)
{
g_print("Debug details: %s\n", debug);
g_free(debug);
}
stop_it = false;
}
if (stop_it)
{
g_print("The stream ended. Let's quit.\n");
//gst_element_set_state(pipeline, GST_STATE_NULL);
//gst_object_unref(pipeline);
//FIXME: causes a segfault
// context->owner_->quit();
}
}
void Chromaprinter::ReportError(GstMessage* msg) {
GError* error;
gchar* debugs;
gst_message_parse_error(msg, &error, &debugs);
QString message = QString::fromLocal8Bit(error->message);
g_error_free(error);
free(debugs);
qLog(Error) << "Error processing" << filename_ << ":" << message;
}
static void
on_bus_error_cb (GstBus *bus, GstMessage *message,
GbpPlayer *player)
{
GError *error;
char *debug;
gst_message_parse_error (message, &error, &debug);
player->priv->reset_state = TRUE;
g_signal_emit (player, player_signals[SIGNAL_ERROR], 0, error, debug);
}
/**
* 错误响应处理函数.
*/
void SoundSystem::ErrorMessageOccur(SoundSystem *sndsys, GstMessage *message)
{
GstElement *pipeline;
GError *error;
gst_message_parse_error(message, &error, NULL);
pwarning(_("Failed to play the prompt tone, %s\n"), error->message);
g_error_free(error);
EosMessageOccur(sndsys);
pipeline = GST_ELEMENT(g_datalist_get_data(&sndsys->eltset, "pipeline-element"));
gst_element_set_state(pipeline, GST_STATE_NULL);
}
/* Not used, didn't work, but left here in case we find a use for it in the future. */
static void PsychMessageErrorCB(GstBus *bus, GstMessage *msg)
{
gchar *debug;
GError *error;
gst_message_parse_error (msg, &error, &debug);
g_free (debug);
printf("PTB-BUSERROR: %s\n", error->message);
g_error_free (error);
return;
}
/* Callback function invoked when a message arrives on the playback
* pipeline's bus. */
static gboolean
bus_callback (GstBus *bus, GstMessage *message, gpointer data)
{
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ERROR: {
/* An error has occurred.
* A real application would probably need to handle this more
* intelligently than just quitting. */
GError *err;
gchar *debug;
gst_message_parse_error(message, &err, &debug);
g_print("Error: %s\n", err->message);
g_error_free(err);
g_free(debug);
gtk_main_quit();
break;
}
case GST_MESSAGE_EOS:
/* The pipeline has reached the end of the stream. */
g_print("End of stream\n");
stop_playback();
gui_status_update(STATE_STOP);
break;
case GST_MESSAGE_TAG: {
/* The stream discovered new tags. */
GstTagList *tags;
gchar *title = "";
gchar *artist = "";
/* Extract from the message the GstTagList.
* This generates a copy, so we must remember to free it.*/
gst_message_parse_tag(message, &tags);
/* Extract the title and artist tags - if they exist */
if (gst_tag_list_get_string(tags, GST_TAG_TITLE, &title)
&& gst_tag_list_get_string(tags, GST_TAG_ARTIST, &artist))
gui_update_metadata(title, artist);
/* Free the tag list */
gst_tag_list_free(tags);
break;
}
default:
/* Another message occurred which we are not interested in handling. */
break;
}
/* We have handled this message, so indicate that it should be removed from
* the queue.*/
return TRUE;
}
static gboolean
capture_bus_cb (GstBus * bus, GstMessage * message, gpointer data)
{
GMainLoop *loop = (GMainLoop *) data;
const GstStructure *st;
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ERROR:{
GError *err = NULL;
gchar *debug = NULL;
gst_message_parse_error (message, &err, &debug);
GST_WARNING ("ERROR: %s [%s]", err->message, debug);
g_error_free (err);
g_free (debug);
/* Write debug graph to file */
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (camera),
GST_DEBUG_GRAPH_SHOW_ALL, "camerabin.error");
fail_if (TRUE, "error while capturing");
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_WARNING:{
GError *err = NULL;
gchar *debug = NULL;
gst_message_parse_warning (message, &err, &debug);
GST_WARNING ("WARNING: %s [%s]", err->message, debug);
g_error_free (err);
g_free (debug);
/* Write debug graph to file */
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (camera),
GST_DEBUG_GRAPH_SHOW_ALL, "camerabin.warning");
break;
}
case GST_MESSAGE_EOS:
GST_DEBUG ("eos");
g_main_loop_quit (loop);
break;
default:
st = gst_message_get_structure (message);
if (st && gst_structure_has_name (st, "image-captured")) {
gboolean ready = FALSE;
GST_INFO ("image captured");
g_object_get (camera, "ready-for-capture", &ready, NULL);
fail_if (!ready, "not ready for capture");
}
break;
}
return TRUE;
}
static void
play_file (const gint delay, const gchar * uri)
{
GstStateChangeReturn sret;
GstMessage *msg;
GstElement *play;
guint wait_nanosecs;
play = gst_element_factory_make ("playbin", "playbin");
g_object_set (play, "uri", uri, NULL);
g_printerr ("Playing %s\n", uri);
sret = gst_element_set_state (play, GST_STATE_PLAYING);
if (sret != GST_STATE_CHANGE_ASYNC && sret != GST_STATE_CHANGE_SUCCESS) {
g_printerr ("ERROR: state change failed, sret=%d\n", sret);
goto next;
}
wait_nanosecs = g_random_int_range (0, GST_MSECOND * delay);
msg = gst_bus_poll (GST_ELEMENT_BUS (play),
GST_MESSAGE_ERROR | GST_MESSAGE_EOS, wait_nanosecs);
if (msg) {
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_ERROR:
{
GError *gerror;
gchar *debug;
gst_message_parse_error (msg, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (msg), gerror, debug);
g_clear_error (&gerror);
g_free (debug);
break;
}
case GST_MESSAGE_EOS:
g_printerr ("Got EOS\n");
break;
default:
g_printerr ("Got unexpected %s messge\n", GST_MESSAGE_TYPE_NAME (msg));
break;
}
gst_message_unref (msg);
goto next;
}
/* on to the next one */
g_print (".");
next:
gst_element_set_state (play, GST_STATE_NULL);
gst_object_unref (play);
}
static gboolean bus_call(GstBus *bus, GstMessage *msg, void *user_data)
{
switch (GST_MESSAGE_TYPE(msg)) {
case GST_MESSAGE_EOS: {
//g_message("End-of-stream");
g_main_loop_quit(loop);
break;
}
case GST_MESSAGE_ERROR: {
GError *err;
gst_message_parse_error(msg, &err, NULL);
//report error
printf ("ERROR: %s", err->message);
g_error_free(err);
g_main_loop_quit(loop);
break;
}
case GST_MESSAGE_ELEMENT: {
const GstStructure *str;
str = gst_message_get_structure (msg);
if (gst_structure_has_name(str,"espeak-mark") ||
gst_structure_has_name(str,"espeak-word")) {
//espeak messages
}
break;
}
//onther element specific message
case GST_MESSAGE_APPLICATION: {
const GstStructure *str;
str = gst_message_get_structure (msg);
if (gst_structure_has_name(str,"turn_off"))
{
g_main_loop_quit(loop);
}
break;
}
default:
break;
}
//printf("info: %i %s\n", (int)(msg->timestamp), GST_MESSAGE_TYPE_NAME (msg));
return true;
}
/* Retrieve errors from the bus and show them on the UI */
static void error_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
GError *err;
gchar *debug_info;
gchar *message_string;
gst_message_parse_error (msg, &err, &debug_info);
message_string = g_strdup_printf ("Error received from element %s: %s", GST_OBJECT_NAME (msg->src), err->message);
g_clear_error (&err);
g_free (debug_info);
set_ui_message (message_string, data);
g_free (message_string);
gst_element_set_state (data->pipeline, GST_STATE_NULL);
}
/* This function is called when an error message is posted on the bus */
static void error_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
GError *err;
gchar *debug_info;
/* Print error details on the screen */
gst_message_parse_error (msg, &err, &debug_info);
g_printerr ("Error received from element %s: %s\n", GST_OBJECT_NAME (msg->src), err->message);
g_printerr ("Debugging information: %s\n", debug_info ? debug_info : "none");
g_clear_error (&err);
g_free (debug_info);
g_main_loop_quit (data->main_loop);
}
