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