static void event_loop (GstElement * pipe) { GstBus *bus; GstMessage *message = NULL; bus = gst_element_get_bus (GST_ELEMENT (pipe)); while (TRUE) { message = gst_bus_poll (bus, GST_MESSAGE_ANY, -1); g_assert (message != NULL); switch (message->type) { case GST_MESSAGE_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; } default: gst_message_unref (message); break; } } }
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; } } }
static void test_missing_suburisource_handler (void) { GstStructure *s; GstMessage *msg; GstElement *playbin; GError *err = NULL; GstBus *bus; playbin = create_playbin ("file:///does/not/exis.t"); g_object_set (playbin, "suburi", "cookie://withahint.of/cinnamon", NULL); fail_unless_equals_int (gst_element_set_state (playbin, GST_STATE_READY), GST_STATE_CHANGE_SUCCESS); fail_unless_equals_int (gst_element_set_state (playbin, GST_STATE_PAUSED), GST_STATE_CHANGE_FAILURE); /* there should be at least a missing-plugin message on the bus now and an * error message; the missing-plugin message should be first */ bus = gst_element_get_bus (playbin); msg = gst_bus_poll (bus, GST_MESSAGE_ELEMENT | GST_MESSAGE_ERROR, -1); fail_unless_equals_int (GST_MESSAGE_TYPE (msg), GST_MESSAGE_ELEMENT); fail_unless (msg->structure != NULL); s = msg->structure; fail_unless (gst_structure_has_name (s, "missing-plugin")); fail_unless (gst_structure_has_field_typed (s, "detail", G_TYPE_STRING)); fail_unless_equals_string (gst_structure_get_string (s, "detail"), "cookie"); fail_unless (gst_structure_has_field_typed (s, "type", G_TYPE_STRING)); fail_unless_equals_string (gst_structure_get_string (s, "type"), "urisource"); gst_message_unref (msg); msg = gst_bus_poll (bus, GST_MESSAGE_ERROR, -1); fail_unless_equals_int (GST_MESSAGE_TYPE (msg), GST_MESSAGE_ERROR); /* make sure the error is a CORE MISSING_PLUGIN one */ gst_message_parse_error (msg, &err, NULL); fail_unless (err != NULL); fail_unless (err->domain == GST_CORE_ERROR, "error has wrong error domain " "%s instead of core-error-quark", g_quark_to_string (err->domain)); fail_unless (err->code == GST_CORE_ERROR_MISSING_PLUGIN, "error has wrong " "code %u instead of GST_CORE_ERROR_MISSING_PLUGIN", err->code); g_error_free (err); gst_message_unref (msg); gst_object_unref (bus); gst_element_set_state (playbin, GST_STATE_NULL); gst_object_unref (playbin); }
/** * 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 void handle_message (CustomData *data, GstMessage *msg) { GError *err; gchar *debug_info; switch (GST_MESSAGE_TYPE (msg)) { case GST_MESSAGE_ERROR: 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); data->terminate = TRUE; break; case GST_MESSAGE_EOS: g_print ("End-Of-Stream reached.\n"); data->terminate = TRUE; break; case GST_MESSAGE_STATE_CHANGED:{ GstState old_state, new_state, pending_state; gst_message_parse_state_changed (msg, &old_state, &new_state, &pending_state); g_print ("%s state changed from %s to %s:\n", GST_OBJECT_NAME (GST_MESSAGE_SRC (msg)), gst_element_state_get_name (old_state), gst_element_state_get_name (new_state)); } break; default: /* We should not reach here */ g_printerr ("Unexpected message received.\n"); break; } gst_message_unref (msg); }
void nvxio::GStreamerBaseRenderImpl::FinalizeGStreamerPipeline() { if (pipeline) { if (num_frames > 0) { gst_app_src_end_of_stream(appsrc); NVXIO_PRINT("Flushing the internal appsrc queue... Please, wait..."); GstMessage * msg = gst_bus_timed_pop_filtered(bus, GST_CLOCK_TIME_NONE, (GstMessageType)(GST_MESSAGE_ERROR | GST_MESSAGE_EOS)); if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_ERROR) NVXIO_PRINT("Error during GStreamer video writer finalization"); else if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_EOS) NVXIO_PRINT("Received EOS. Finished output file writing."); if (msg != NULL) gst_message_unref(msg); } gst_object_unref(GST_OBJECT(bus)); bus = NULL; gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_NULL); gst_object_unref(GST_OBJECT(pipeline)); pipeline = NULL; } }
static void check_get_dtmf_event_message (GstBus * bus, gint number, gint volume) { GstMessage *message; gboolean have_message = FALSE; while (!have_message && (message = gst_bus_pop_filtered (bus, GST_MESSAGE_ELEMENT)) != NULL) { if (gst_message_has_name (message, "dtmf-event")) { const GstStructure *s = gst_message_get_structure (message); gint stype, snumber, smethod, svolume; fail_unless (gst_structure_get (s, "type", G_TYPE_INT, &stype, "number", G_TYPE_INT, &snumber, "method", G_TYPE_INT, &smethod, "volume", G_TYPE_INT, &svolume, NULL)); fail_unless (stype == 1); fail_unless (smethod == 1); fail_unless (snumber == number); fail_unless (svolume == volume); have_message = TRUE; } gst_message_unref (message); } fail_unless (have_message); }
GstBusSyncReply TGstEngine::bus_cb(GstBus*, GstMessage* msg, gpointer pinfo) // static { PlayInfo *playInfo = static_cast<PlayInfo *>(pinfo); switch (GST_MESSAGE_TYPE(msg)) { case GST_MESSAGE_ERROR: { GError* error; gchar* debugs; gst_message_parse_error(msg,&error,&debugs); qDebug() << "ERROR RECEIVED IN BUS_CB <" << error->message << ">"; playInfo->engine->destroyPlayInfo(playInfo); delete playInfo; } break; case GST_MESSAGE_EOS: { qDebug() << "FINISHED " << playInfo->id; } break; default: ; } gst_message_unref(msg); return GST_BUS_DROP; }
void NWaveformBuilderGstreamer::update() { GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(m_playbin)); GstMessage *msg = gst_bus_pop_filtered(bus, GstMessageType(GST_MESSAGE_EOS | GST_MESSAGE_ERROR)); if (msg) { switch (GST_MESSAGE_TYPE(msg)) { case GST_MESSAGE_EOS: peaks()->complete(); #if defined(QT_DEBUG) && !defined(QT_NO_DEBUG) qDebug() << "WaveformBuilder ::" << "completed" << peaks()->size(); #endif stop(); break; case GST_MESSAGE_ERROR: #if defined(QT_DEBUG) && !defined(QT_NO_DEBUG) gchar *debug; GError *err = NULL; gst_message_parse_error(msg, &err, &debug); g_free(debug); qWarning() << "WaveformBuilder :: error ::" << QString::fromUtf8(err->message); if (err) g_error_free(err); #endif break; default: break; } gst_message_unref(msg); } gst_object_unref(bus); }
static GstBusSyncReply gst_uri_downloader_bus_handler (GstBus * bus, GstMessage * message, gpointer data) { GstUriDownloader *downloader = (GstUriDownloader *) (data); if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR) { GError *err = NULL; gchar *dbg_info = NULL; gchar *new_error = NULL; gst_message_parse_error (message, &err, &dbg_info); GST_WARNING_OBJECT (downloader, "Received error: %s from %s, the download will be cancelled", err->message, GST_OBJECT_NAME (message->src)); GST_DEBUG ("Debugging info: %s\n", (dbg_info) ? dbg_info : "none"); if (dbg_info) new_error = g_strdup_printf ("%s: %s\n", err->message, dbg_info); if (new_error) { g_free (err->message); err->message = new_error; } if (!downloader->priv->err) downloader->priv->err = err; else g_error_free (err); g_free (dbg_info); /* remove the sync handler to avoid duplicated messages */ gst_bus_set_sync_handler (downloader->priv->bus, NULL, NULL, NULL); /* stop the download */ GST_OBJECT_LOCK (downloader); if (downloader->priv->download != NULL) { GST_DEBUG_OBJECT (downloader, "Stopping download"); g_object_unref (downloader->priv->download); downloader->priv->download = NULL; downloader->priv->cancelled = TRUE; g_cond_signal (&downloader->priv->cond); } GST_OBJECT_UNLOCK (downloader); } else if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_WARNING) { GError *err = NULL; gchar *dbg_info = NULL; gst_message_parse_warning (message, &err, &dbg_info); GST_WARNING_OBJECT (downloader, "Received warning: %s from %s", GST_OBJECT_NAME (message->src), err->message); GST_DEBUG ("Debugging info: %s\n", (dbg_info) ? dbg_info : "none"); g_error_free (err); g_free (dbg_info); } gst_message_unref (message); return GST_BUS_DROP; }
void MyGstreamer::start() { qDebug("Gstreamer Started..."); GstElement *pipeline; GstBus *bus; GstMessage *msg; /* Initialize GStreamer */ gst_init (0, 0); /* Build the pipeline */ pipeline = gst_parse_launch ("playbin2 uri=http://docs.gstreamer.com/media/sintel_trailer-480p.webm", NULL); /* Start playing */ gst_element_set_state (pipeline, GST_STATE_PLAYING); /* Wait until error or EOS */ bus = gst_element_get_bus (pipeline); msg = gst_bus_timed_pop_filtered (bus, GST_CLOCK_TIME_NONE, (GstMessageType)(GST_MESSAGE_ERROR | GST_MESSAGE_EOS)); /* Free resources */ if (msg != NULL) gst_message_unref (msg); gst_object_unref (bus); gst_element_set_state (pipeline, GST_STATE_NULL); gst_object_unref (pipeline); }
static void bus_handler (GstBin * bin, GstMessage * message) { GstSplitMuxSink *splitmux = GST_SPLITMUX_SINK (bin); switch (GST_MESSAGE_TYPE (message)) { case GST_MESSAGE_EOS: /* If the state is draining out the current file, drop this EOS */ GST_SPLITMUX_LOCK (splitmux); if (splitmux->state == SPLITMUX_STATE_ENDING_FILE && splitmux->max_out_running_time != GST_CLOCK_TIME_NONE) { GST_DEBUG_OBJECT (splitmux, "Caught EOS at end of fragment, dropping"); splitmux->state = SPLITMUX_STATE_START_NEXT_FRAGMENT; GST_SPLITMUX_BROADCAST (splitmux); gst_message_unref (message); GST_SPLITMUX_UNLOCK (splitmux); return; } GST_SPLITMUX_UNLOCK (splitmux); break; default: break; } GST_BIN_CLASS (parent_class)->handle_message (bin, message); }
static GstBusSyncReply create_window (GstBus * bus, GstMessage * message, gpointer data) { GstGLClutterActor **actor = (GstGLClutterActor **) data; static gint count = 0; static GMutex *mutex = NULL; // ignore anything but 'prepare-xwindow-id' element messages if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT) return GST_BUS_PASS; if (!gst_structure_has_name (message->structure, "prepare-xwindow-id")) return GST_BUS_PASS; if (!mutex) mutex = g_mutex_new (); g_mutex_lock (mutex); if (count < N_ACTORS) { g_message ("adding actor %d", count); gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (GST_MESSAGE_SRC (message)), actor[count]->win); clutter_threads_add_idle ((GSourceFunc) create_actor, actor[count]); count++; } g_mutex_unlock (mutex); gst_message_unref (message); return GST_BUS_DROP; }
static void test_bt_log_message_warning (BT_TEST_ARGS) { BT_TEST_START; GST_INFO ("-- arrange --"); GstObject *src = (GstObject *) gst_element_factory_make ("fakesrc", NULL); GError *error = g_error_new (GST_CORE_ERROR, GST_CORE_ERROR_FAILED, "description"); GstMessage *msg = gst_message_new_warning (src, error, "debug"); gchar *message, *description; GST_INFO ("-- act --"); gboolean res = bt_gst_log_message_warning (GST_CAT_DEFAULT, __FILE__, "", __LINE__, msg, &message, &description); GST_INFO ("-- assert --"); fail_unless (res, NULL); fail_unless (description != NULL, NULL); ck_assert_str_eq (message, "description"); GST_INFO ("-- cleanup --"); g_free (message); g_free (description); gst_message_unref (msg); gst_object_unref (src); BT_TEST_END; }
static void gst_bus_dispose (GObject * object) { GstBus *bus = GST_BUS (object); if (bus->priv->queue) { GstMessage *message; g_mutex_lock (&bus->priv->queue_lock); do { message = gst_atomic_queue_pop (bus->priv->queue); if (message) gst_message_unref (message); } while (message != NULL); gst_atomic_queue_unref (bus->priv->queue); bus->priv->queue = NULL; g_mutex_unlock (&bus->priv->queue_lock); g_mutex_clear (&bus->priv->queue_lock); if (bus->priv->poll) gst_poll_free (bus->priv->poll); bus->priv->poll = NULL; } G_OBJECT_CLASS (parent_class)->dispose (object); }
int main(int argc, char *argv[]) { GstElement *pipeline; GstBus *bus; GstMessage *msg; /* Initialize GStreamer */ gst_init (&argc, &argv); /* Build the pipeline */ pipeline = gst_parse_launch ("playbin2 uri=http://docs.gstreamer.com/media/sintel_trailer-480p.webm", NULL); /* Start playing */ gst_element_set_state (pipeline, GST_STATE_PLAYING); /* Wait until error or EOS */ bus = gst_element_get_bus (pipeline); msg = gst_bus_timed_pop_filtered (bus, GST_CLOCK_TIME_NONE, GST_MESSAGE_ERROR | GST_MESSAGE_EOS); /* Free resources */ if (msg != NULL) gst_message_unref (msg); gst_object_unref (bus); gst_element_set_state (pipeline, GST_STATE_NULL); gst_object_unref (pipeline); return 0; }
static void pull_messages (void) { GstMessage *m; const GstStructure *s; guint message_ids[NUM_THREADS]; gint i; for (i = 0; i < NUM_THREADS; i++) message_ids[i] = 0; while (1) { gint _t, _i; m = gst_bus_pop (test_bus); if (!m) break; g_return_if_fail (GST_MESSAGE_TYPE (m) == GST_MESSAGE_APPLICATION); s = gst_message_get_structure (m); if (!gst_structure_get_int (s, "thread_id", &_t)) g_critical ("Invalid message"); if (!gst_structure_get_int (s, "msg_id", &_i)) g_critical ("Invalid message"); g_return_if_fail (_t < NUM_THREADS); g_return_if_fail (_i == message_ids[_t]++); gst_message_unref (m); } for (i = 0; i < NUM_THREADS; i++) g_return_if_fail (message_ids[i] == NUM_MESSAGES); }
static GstBusSyncReply create_window (GstBus* bus, GstMessage* message, GtkWidget* widget) { GtkAllocation allocation; if (gst_gtk_handle_need_context (bus, message, NULL)) return GST_BUS_DROP; // ignore anything but 'prepare-window-handle' element messages if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT) return GST_BUS_PASS; if (!gst_is_video_overlay_prepare_window_handle_message (message)) return GST_BUS_PASS; g_print ("setting window handle %p\n", widget); gst_video_overlay_set_gtk_window (GST_VIDEO_OVERLAY (GST_MESSAGE_SRC (message)), widget); gtk_widget_get_allocation (widget, &allocation); gst_video_overlay_set_render_rectangle (GST_VIDEO_OVERLAY (GST_MESSAGE_SRC (message)), allocation.x, allocation.y, allocation.width, allocation.height); gst_message_unref (message); return GST_BUS_DROP; }
static void play_file (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); sret = gst_element_set_state (play, GST_STATE_PLAYING); if (sret != GST_STATE_CHANGE_ASYNC) { g_printerr ("ERROR: state change failed, sret=%d\n", sret); goto next; } wait_nanosecs = g_random_int_range (0, GST_SECOND / 10); msg = gst_bus_poll (GST_ELEMENT_BUS (play), GST_MESSAGE_ERROR | GST_MESSAGE_EOS, wait_nanosecs); if (msg) { g_printerr ("Got %s messge\n", GST_MESSAGE_TYPE_NAME (msg)); gst_message_unref (msg); goto next; } /* on to the next one */ g_print ("."); next: gst_element_set_state (play, GST_STATE_NULL); }
static GstBusSyncReply gst_uri_downloader_bus_handler (GstBus * bus, GstMessage * message, gpointer data) { GstUriDownloader *downloader = (GstUriDownloader *) (data); if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR || GST_MESSAGE_TYPE (message) == GST_MESSAGE_WARNING) { GError *err = NULL; gchar *dbg_info = NULL; gst_message_parse_error (message, &err, &dbg_info); GST_WARNING_OBJECT (downloader, "Received error: %s from %s, the download will be cancelled", GST_OBJECT_NAME (message->src), err->message); GST_DEBUG ("Debugging info: %s\n", (dbg_info) ? dbg_info : "none"); g_error_free (err); g_free (dbg_info); /* remove the sync handler to avoid duplicated messages */ gst_bus_set_sync_handler (downloader->priv->bus, NULL, NULL); gst_uri_downloader_cancel (downloader); } gst_message_unref (message); return GST_BUS_DROP; }
JNIEXPORT jint JNICALL Java_gstJNI_pipelineLaunch(JNIEnv *env, jobject thisObj, jstring launch) { //First, we need to convert the JNI string to a char* const char *inCStr = (*env)->GetStringUTFChars(env, launch, NULL); if(inCStr == NULL) return -1; //error check //printf("In C, the received string is: %s\n", inCStr); GstElement *pipeline; GstBus *bus; GstMessage *msg; GError *e; e = NULL; //Initialize GStreamer gst_init (0, NULL); //still not sure what kind of arguments go here pipeline = gst_parse_launch(inCStr, &e); /* Start playing */ gst_element_set_state (pipeline, GST_STATE_PLAYING); /* Wait until error or EOS */ bus = gst_element_get_bus (pipeline); msg = gst_bus_timed_pop_filtered (bus, GST_CLOCK_TIME_NONE, GST_MESSAGE_ERROR | GST_MESSAGE_EOS); /* Free resources */ if (msg != NULL) gst_message_unref (msg); gst_object_unref (bus); gst_element_set_state (pipeline, GST_STATE_NULL); gst_object_unref (pipeline); (*env)->ReleaseStringUTFChars(env, launch, inCStr); return 0; }
nsRefPtr<MediaDecoderReader::SeekPromise> GStreamerReader::Seek(int64_t aTarget, int64_t aEndTime) { MOZ_ASSERT(OnTaskQueue()); gint64 seekPos = aTarget * GST_USECOND; LOG(LogLevel::Debug, "%p About to seek to %" GST_TIME_FORMAT, mDecoder, GST_TIME_ARGS(seekPos)); int flags = GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT; if (!gst_element_seek_simple(mPlayBin, GST_FORMAT_TIME, static_cast<GstSeekFlags>(flags), seekPos)) { LOG(LogLevel::Error, "seek failed"); return SeekPromise::CreateAndReject(NS_ERROR_FAILURE, __func__); } LOG(LogLevel::Debug, "seek succeeded"); GstMessage* message = gst_bus_timed_pop_filtered(mBus, GST_CLOCK_TIME_NONE, (GstMessageType)(GST_MESSAGE_ASYNC_DONE | GST_MESSAGE_ERROR)); gst_message_unref(message); LOG(LogLevel::Debug, "seek completed"); return SeekPromise::CreateAndResolve(aTarget, __func__); }
static GstBusSyncReply create_window (GstBus * bus, GstMessage * message, gpointer data) { GstGLClutterActor **actor = (GstGLClutterActor **) data; static gint count = 0; static GMutex mutex; // ignore anything but 'prepare-window-handle' element messages if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT) return GST_BUS_PASS; if (!gst_is_video_overlay_prepare_window_handle_message (message)) return GST_BUS_PASS; g_mutex_lock (&mutex); if (count < N_ACTORS) { g_message ("adding actor %d", count); gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (GST_MESSAGE_SRC (message)), actor[count]->win); clutter_threads_add_idle ((GSourceFunc) create_actor, actor[count]); count++; } g_mutex_unlock (&mutex); gst_message_unref (message); return GST_BUS_DROP; }
/*! * \brief CvVideoWriter_GStreamer::close * ends the pipeline by sending EOS and destroys the pipeline and all * elements afterwards */ void CvVideoWriter_GStreamer::close() { if (pipeline) { gst_app_src_end_of_stream(GST_APP_SRC(source)); //wait for EOS to trickle down the pipeline. This will let all elements finish properly GstBus* bus = gst_element_get_bus(pipeline); GstMessage *msg = gst_bus_timed_pop_filtered(bus, GST_CLOCK_TIME_NONE, (GstMessageType)(GST_MESSAGE_ERROR | GST_MESSAGE_EOS)); if(msg != NULL){ gst_message_unref(msg); g_object_unref(G_OBJECT(bus)); } gst_element_set_state (pipeline, GST_STATE_NULL); handleMessage(pipeline); gst_object_unref (GST_OBJECT (pipeline)); if (source) gst_object_unref (GST_OBJECT (source)); if (file) gst_object_unref (GST_OBJECT (file)); } }
void Pipeline::start () { // set a callback to retrieve the gst gl textures GstElement *fakesink = gst_bin_get_by_name (GST_BIN (this->m_pipeline), "fakesink0"); g_object_set (G_OBJECT (fakesink), "signal-handoffs", TRUE, NULL); g_signal_connect (fakesink, "handoff", G_CALLBACK (on_gst_buffer), this); gst_object_unref (fakesink); GstStateChangeReturn ret = gst_element_set_state (GST_ELEMENT (this->m_pipeline), GST_STATE_PLAYING); if (ret == GST_STATE_CHANGE_FAILURE) { qDebug ("Failed to start up pipeline!"); /* check if there is an error message with details on the bus */ GstMessage *msg = gst_bus_poll (this->m_bus, GST_MESSAGE_ERROR, 0); if (msg) { GError *err = NULL; gst_message_parse_error (msg, &err, NULL); qDebug ("ERROR: %s", err->message); g_error_free (err); gst_message_unref (msg); } return; } #ifdef Q_WS_WIN g_main_loop_run (m_loop); #endif }
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; } default: break; } return TRUE; }
static void gst_bus_dispose (GObject * object) { GstBus *bus; bus = GST_BUS (object); if (bus->queue) { GstMessage *message; g_mutex_lock (bus->queue_lock); do { message = g_queue_pop_head (bus->queue); if (message) gst_message_unref (message); } while (message != NULL); g_queue_free (bus->queue); bus->queue = NULL; g_mutex_unlock (bus->queue_lock); g_mutex_free (bus->queue_lock); bus->queue_lock = NULL; g_cond_free (bus->priv->queue_cond); bus->priv->queue_cond = NULL; } if (bus->priv->main_context) { g_main_context_unref (bus->priv->main_context); bus->priv->main_context = NULL; } G_OBJECT_CLASS (parent_class)->dispose (object); }
static GstBusSyncReply sync_bus_callback (GstBus * bus, GstMessage * message, gpointer data) { const GstStructure *st; const GValue *image; GstBuffer *buf = NULL; guint8 *data_buf = NULL; gchar *caps_string; guint size = 0; gchar *preview_filename = NULL; FILE *f = NULL; size_t written; switch (GST_MESSAGE_TYPE (message)) { case GST_MESSAGE_ELEMENT:{ st = gst_message_get_structure (message); if (st) { if (gst_structure_has_name (message->structure, "prepare-xwindow-id")) { if (!no_xwindow && window) { gst_x_overlay_set_window_handle (GST_X_OVERLAY (GST_MESSAGE_SRC (message)), window); gst_message_unref (message); message = NULL; return GST_BUS_DROP; } } else if (gst_structure_has_name (st, "preview-image")) { GST_DEBUG ("preview-image"); /* extract preview-image from msg */ image = gst_structure_get_value (st, "buffer"); if (image) { buf = gst_value_get_buffer (image); data_buf = GST_BUFFER_DATA (buf); size = GST_BUFFER_SIZE (buf); preview_filename = g_strdup_printf ("test_vga.rgb"); caps_string = gst_caps_to_string (GST_BUFFER_CAPS (buf)); g_print ("writing buffer to %s, elapsed: %.2fs, buffer caps: %s\n", preview_filename, g_timer_elapsed (timer, NULL), caps_string); g_free (caps_string); f = g_fopen (preview_filename, "w"); if (f) { written = fwrite (data_buf, size, 1, f); if (!written) { g_print ("error writing file\n"); } fclose (f); } else { g_print ("error opening file for raw image writing\n"); } g_free (preview_filename); } } } break; } default: /* unhandled message */ break; } return GST_BUS_PASS; }
void GStreamerReader::Seek(int64_t aTarget, int64_t aStartTime, int64_t aEndTime, int64_t aCurrentTime) { NS_ASSERTION(mDecoder->OnDecodeThread(), "Should be on decode thread."); gint64 seekPos = aTarget * GST_USECOND; LOG(PR_LOG_DEBUG, "%p About to seek to %" GST_TIME_FORMAT, mDecoder, GST_TIME_ARGS(seekPos)); int flags = GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT; if (!gst_element_seek_simple(mPlayBin, GST_FORMAT_TIME, static_cast<GstSeekFlags>(flags), seekPos)) { LOG(PR_LOG_ERROR, "seek failed"); GetCallback()->OnSeekCompleted(NS_ERROR_FAILURE); return; } LOG(PR_LOG_DEBUG, "seek succeeded"); GstMessage* message = gst_bus_timed_pop_filtered(mBus, GST_CLOCK_TIME_NONE, (GstMessageType)(GST_MESSAGE_ASYNC_DONE | GST_MESSAGE_ERROR)); gst_message_unref(message); LOG(PR_LOG_DEBUG, "seek completed"); GetCallback()->OnSeekCompleted(NS_OK); }
static void handle_current_sync (GstDiscoverer * dc) { GTimer *timer; gdouble deadline = ((gdouble) dc->priv->timeout) / GST_SECOND; GstMessage *msg; gboolean done = FALSE; timer = g_timer_new (); g_timer_start (timer); do { /* poll bus with timeout */ /* FIXME : make the timeout more fine-tuned */ if ((msg = gst_bus_timed_pop (dc->priv->bus, GST_SECOND / 2))) { done = handle_message (dc, msg); gst_message_unref (msg); } } while (!done && (g_timer_elapsed (timer, NULL) < deadline)); /* return result */ if (!done) { GST_DEBUG ("we timed out! Setting result to TIMEOUT"); dc->priv->current_info->result = GST_DISCOVERER_TIMEOUT; } GST_DEBUG ("Done"); g_timer_stop (timer); g_timer_destroy (timer); }