/* doesn't return a ref to the pixbuf */ static GdkPixbuf * check_message_pixbuf (GstMessage * msg, const gchar * name, gint channels, gboolean has_alpha) { GdkPixbuf *pixbuf; const GstStructure *s; fail_unless (gst_message_get_structure (msg) != NULL); s = gst_message_get_structure (msg); fail_unless_equals_string (gst_structure_get_name (s), name); fail_unless (gst_structure_has_field (s, "pixbuf")); fail_unless (gst_structure_has_field_typed (s, "pixel-aspect-ratio", GST_TYPE_FRACTION)); pixbuf = GDK_PIXBUF (g_value_get_object (gst_structure_get_value (s, "pixbuf"))); fail_unless (GDK_IS_PIXBUF (pixbuf)); fail_unless_equals_int (gdk_pixbuf_get_n_channels (pixbuf), channels); fail_unless_equals_int (gdk_pixbuf_get_has_alpha (pixbuf), has_alpha); fail_unless_equals_int (gdk_pixbuf_get_width (pixbuf), 319); fail_unless_equals_int (gdk_pixbuf_get_height (pixbuf), 241); return pixbuf; }
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; }
static void gst_level_message_append_channel (GstMessage * m, gdouble rms, gdouble peak, gdouble decay) { const GValue *array_val; GstStructure *s; GValueArray *arr; GValue v = { 0, }; g_value_init (&v, G_TYPE_DOUBLE); s = (GstStructure *) gst_message_get_structure (m); array_val = gst_structure_get_value (s, "rms"); arr = (GValueArray *) g_value_get_boxed (array_val); g_value_set_double (&v, rms); g_value_array_append (arr, &v); /* copies by value */ array_val = gst_structure_get_value (s, "peak"); arr = (GValueArray *) g_value_get_boxed (array_val); g_value_set_double (&v, peak); g_value_array_append (arr, &v); /* copies by value */ array_val = gst_structure_get_value (s, "decay"); arr = (GValueArray *) g_value_get_boxed (array_val); g_value_set_double (&v, decay); g_value_array_append (arr, &v); /* copies by value */ g_value_unset (&v); }
/* This function is called when an "application" message is posted on the bus. * Here we retrieve the message posted by the tags_cb callback */ static void application_cb (GstBus *bus, GstMessage *msg, CustomData *data) { if (g_strcmp0 (gst_structure_get_name (gst_message_get_structure (msg)), "tags-changed") == 0) { /* If the message is the "tags-changed" (only one we are currently issuing), update * the stream info GUI */ analyze_streams (data); } }
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); }
void ZBarFilterImpl::busMessage (GstMessage *message) { if (GST_MESSAGE_SRC (message) == GST_OBJECT (zbar) && GST_MESSAGE_TYPE (message) == GST_MESSAGE_ELEMENT) { const GstStructure *st; guint64 ts; gchar *type, *symbol; st = gst_message_get_structure (message); if (g_strcmp0 (gst_structure_get_name (st), "barcode") != 0) { return; } if (!gst_structure_get (st, "timestamp", G_TYPE_UINT64, &ts, "type", G_TYPE_STRING, &type, "symbol", G_TYPE_STRING, &symbol, NULL) ) { return; } std::string symbolStr (symbol); std::string typeStr (type); g_free (type); g_free (symbol); barcodeDetected (ts, typeStr, symbolStr); } }
EXPORT_C #endif GstNavigationMessageType gst_navigation_message_get_type (GstMessage * message) { const GstStructure *s; const gchar *m_type; if (message == NULL || GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT) return GST_NAVIGATION_MESSAGE_INVALID; s = gst_message_get_structure (message); if (s == NULL || !gst_structure_has_name (s, GST_NAVIGATION_MESSAGE_NAME)) return GST_NAVIGATION_MESSAGE_INVALID; m_type = gst_structure_get_string (s, "type"); if (m_type == NULL) return GST_NAVIGATION_MESSAGE_INVALID; if (g_str_equal (m_type, "mouse-over")) return GST_NAVIGATION_MESSAGE_MOUSE_OVER; else if (g_str_equal (m_type, "commands-changed")) return GST_NAVIGATION_MESSAGE_COMMANDS_CHANGED; else if (g_str_equal (m_type, "angles-changed")) return GST_NAVIGATION_MESSAGE_ANGLES_CHANGED; return GST_NAVIGATION_MESSAGE_INVALID; }
EXPORT_C #endif void gst_mixer_message_parse_option_changed (GstMessage * message, GstMixerOptions ** options, const gchar ** value) { const GstStructure *s; g_return_if_fail (gst_mixer_message_is_mixer_message (message)); g_return_if_fail (GST_MIXER_MESSAGE_HAS_TYPE (message, OPTION_CHANGED)); s = gst_message_get_structure (message); if (options) { const GValue *v = gst_structure_get_value (s, "options"); g_return_if_fail (v != NULL); *options = (GstMixerOptions *) g_value_get_object (v); g_return_if_fail (GST_IS_MIXER_OPTIONS (*options)); } if (value) *value = gst_structure_get_string (s, "value"); }
static void dvb_base_bin_handle_message (GstBin * bin, GstMessage * message) { DvbBaseBin *dvbbasebin; dvbbasebin = GST_DVB_BASE_BIN (bin); if (message->type == GST_MESSAGE_ELEMENT && GST_ELEMENT (message->src) == GST_ELEMENT (dvbbasebin->mpegtsparse)) { const GstStructure *s = gst_message_get_structure (message); const gchar *structure_name = gst_structure_get_name (s); if (strcmp (structure_name, "pat") == 0) dvb_base_bin_pat_info_cb (dvbbasebin, s); else if (strcmp (structure_name, "pmt") == 0) dvb_base_bin_pmt_info_cb (dvbbasebin, s); /*else if (strcmp (structure_name, "nit") == 0) dvb_base_bin_nit_info_cb (dvbbasebin, message->structure); else if (strcmp (structure_name, "sdt") == 0) dvb_base_bin_sdt_info_cb (dvbbasebin, message->structure); else if (strcmp (structure_name, "eit") == 0) dvb_base_bin_eit_info_cb (dvbbasebin, message->structure); */ /* forward the message on */ gst_element_post_message (GST_ELEMENT_CAST (bin), message); } else { /* chain up */ GST_BIN_CLASS (parent_class)->handle_message (bin, message); } }
EXPORT_C #endif GstMixerMessageType gst_mixer_message_get_type (GstMessage * message) { const GstStructure *s; const gchar *m_type; if (!gst_mixer_message_is_mixer_message (message)) return GST_MIXER_MESSAGE_INVALID; s = gst_message_get_structure (message); m_type = gst_structure_get_string (s, "type"); g_return_val_if_fail (m_type != NULL, GST_MIXER_MESSAGE_INVALID); if (g_str_equal (m_type, "mute-toggled")) return GST_MIXER_MESSAGE_MUTE_TOGGLED; else if (g_str_equal (m_type, "record-toggled")) return GST_MIXER_MESSAGE_RECORD_TOGGLED; else if (g_str_equal (m_type, "volume-changed")) return GST_MIXER_MESSAGE_VOLUME_CHANGED; else if (g_str_equal (m_type, "option-changed")) return GST_MIXER_MESSAGE_OPTION_CHANGED; else if (g_str_equal (m_type, "options-list-changed")) return GST_MIXER_MESSAGE_OPTIONS_LIST_CHANGED; else if (g_str_equal (m_type, "mixer-changed")) return GST_MIXER_MESSAGE_MIXER_CHANGED; return GST_MIXER_MESSAGE_INVALID; }
EXPORT_C #endif void gst_mixer_message_parse_record_toggled (GstMessage * message, GstMixerTrack ** track, gboolean * record) { const GstStructure *s; g_return_if_fail (gst_mixer_message_is_mixer_message (message)); g_return_if_fail (GST_MIXER_MESSAGE_HAS_TYPE (message, RECORD_TOGGLED)); s = gst_message_get_structure (message); if (track) { const GValue *v = gst_structure_get_value (s, "track"); g_return_if_fail (v != NULL); *track = (GstMixerTrack *) g_value_get_object (v); g_return_if_fail (GST_IS_MIXER_TRACK (*track)); } if (record) g_return_if_fail (gst_structure_get_boolean (s, "record", record)); }
/** * fs_stream_parse_component_state_changed: * @stream: a #FsStream to match against the message * @message: a #GstMessage to parse * @component: (out): Returns the component from the #GstMessage if not %NULL * @state: (out): Returns the #FsStreamState from the #GstMessage if not %NULL * * Parses a "farstream-component-state-changed" message and checks if it matches * the @stream parameters. * * Returns: %TRUE if the message matches the stream and is valid. */ gboolean fs_stream_parse_component_state_changed (FsStream *stream, GstMessage *message, guint *component, FsStreamState *state) { const GstStructure *s; const GValue *value; g_return_val_if_fail (stream != NULL, FALSE); if (!check_message (message, stream, "farstream-component-state-changed")) return FALSE; s = gst_message_get_structure (message); value = gst_structure_get_value (s, "component"); if (!value || !G_VALUE_HOLDS (value, G_TYPE_UINT)) return FALSE; if (component) *component = g_value_get_uint (value); value = gst_structure_get_value (s, "state"); if (!value || !G_VALUE_HOLDS (value, G_TYPE_ENUM)) return FALSE; if (state) *state = g_value_get_enum (value); return TRUE; }
/** * fs_stream_parse_new_active_candidate_pair: * @stream: a #FsStream to match against the message * @message: a #GstMessage to parse * @local_candidate: (out) (transfer none): Returns the local #FsCandidate in * the message if not %NULL. * @remote_candidate: (out) (transfer none): Returns the remote #FsCandidate in * the message if not %NULL. * * Parses a "farstream-new-active-candidate-pair" message and checks * if it matches the @stream parameters. * * Returns: %TRUE if the message matches the stream and is valid. */ gboolean fs_stream_parse_new_active_candidate_pair (FsStream *stream, GstMessage *message, FsCandidate **local_candidate, FsCandidate **remote_candidate) { const GstStructure *s; const GValue *value; g_return_val_if_fail (stream != NULL, FALSE); if (!check_message (message, stream, "farstream-new-active-candidate-pair")) return FALSE; s = gst_message_get_structure (message); value = gst_structure_get_value (s, "local-candidate"); if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CANDIDATE)) return FALSE; if (local_candidate) *local_candidate = g_value_get_boxed (value); value = gst_structure_get_value (s, "remote-candidate"); if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CANDIDATE)) return FALSE; if (remote_candidate) *remote_candidate = g_value_get_boxed (value); return TRUE; }
static gboolean check_message (GstMessage *message, FsStream *stream, const gchar *message_name) { const GstStructure *s; const GValue *value; FsStream *message_stream; if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT) return FALSE; s = gst_message_get_structure (message); if (!gst_structure_has_name (s, message_name)) return FALSE; value = gst_structure_get_value (s, "stream"); if (!value || !G_VALUE_HOLDS (value, FS_TYPE_STREAM)) return FALSE; message_stream = g_value_get_object (value); if (stream != message_stream) return FALSE; return TRUE; }
/** * fs_session_parse_send_codec_changed: * @session: a #FsSession to match against the message * @message: a #GstMessage to parse * @codec: (out) (transfer none): Returns the #FsCodec in the message if not * %NULL. * @secondary_codecs: (out) (transfer none) (element-type FsCodec): * Returns a #GList of #FsCodec of the message if not %NULL * * Parses a "farstream-send-codec-changed" message and checks if it matches * the @session parameters. * * Returns: %TRUE if the message matches the session and is valid. */ gboolean fs_session_parse_send_codec_changed ( FsSession *session, GstMessage *message, FsCodec **codec, GList **secondary_codecs) { const GstStructure *s; const GValue *value; g_return_val_if_fail (session != NULL, FALSE); if (!check_message (message, session, "farstream-send-codec-changed")) return FALSE; s = gst_message_get_structure (message); value = gst_structure_get_value (s, "codec"); if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CODEC)) return FALSE; if (codec) *codec = g_value_get_boxed (value); value = gst_structure_get_value (s, "secondary-codecs"); if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CODEC_LIST)) return FALSE; if (secondary_codecs) *secondary_codecs = g_value_get_boxed (value); return TRUE; }
void zbar_receive_message (GstBus *bus, GstMessage *message, gpointer zbar) { ZBarFilter *filter = (ZBarFilter *) zbar; if (GST_MESSAGE_SRC (message) == GST_OBJECT (filter->zbar) && GST_MESSAGE_TYPE (message) == GST_MESSAGE_ELEMENT) { const GstStructure *st; guint64 ts; gchar *type, *symbol; st = gst_message_get_structure (message); if (g_strcmp0 (gst_structure_get_name (st), "barcode") != 0) return; if (!gst_structure_get (st, "timestamp", G_TYPE_UINT64, &ts, "type", G_TYPE_STRING, &type, "symbol", G_TYPE_STRING, &symbol, NULL) ) return; std::string symbolStr (symbol); std::string typeStr (type); g_free (type); g_free (symbol); filter->barcodeDetected (ts, typeStr, symbolStr); } }
/** * fs_session_parse_telephony_event_started: * @session: a #FsSession to match against the message * @message: a #GstMessage to parse * @method: (out): Returns the #FsDTMFMethod in the message if not %NULL. * @event: (out): Returns the #FsDTMFEvent in the message if not %NULL. * @volume: (out): Returns the volume in the message if not %NULL. * * Parses a "farstream-telephony-event-started" message and checks if it matches * the @session parameters. * * Returns: %TRUE if the message matches the session and is valid. */ gboolean fs_session_parse_telephony_event_started (FsSession *session, GstMessage *message, FsDTMFMethod *method, FsDTMFEvent *event, guint8 *volume) { const GstStructure *s; const GValue *value; g_return_val_if_fail (session != NULL, FALSE); if (!check_message (message, session, "farstream-telephony-event-started")) return FALSE; s = gst_message_get_structure (message); if (!gst_structure_has_field_typed (s, "method", FS_TYPE_DTMF_METHOD)) return FALSE; if (method) gst_structure_get_enum (s, "method", FS_TYPE_DTMF_METHOD, (gint*) method); if (!gst_structure_has_field_typed (s, "event", FS_TYPE_DTMF_EVENT)) return FALSE; if (event) gst_structure_get_enum (s, "event", FS_TYPE_DTMF_EVENT, (gint*) event); value = gst_structure_get_value (s, "volume"); if (!value || !G_VALUE_HOLDS (value, G_TYPE_UCHAR)) return FALSE; if (volume) *volume = g_value_get_uchar (value); return TRUE; }
void CameraBinFocus::handleFocusMessage(GstMessage *gm) { //it's a sync message, so it's called from non main thread const GstStructure *structure = gst_message_get_structure(gm); if (gst_structure_has_name(structure, GST_PHOTOGRAPHY_AUTOFOCUS_DONE)) { gint status = GST_PHOTOGRAPHY_FOCUS_STATUS_NONE; gst_structure_get_int (structure, "status", &status); QCamera::LockStatus focusStatus = m_focusStatus; QCamera::LockChangeReason reason = QCamera::UserRequest; switch (status) { case GST_PHOTOGRAPHY_FOCUS_STATUS_FAIL: focusStatus = QCamera::Unlocked; reason = QCamera::LockFailed; break; case GST_PHOTOGRAPHY_FOCUS_STATUS_SUCCESS: focusStatus = QCamera::Locked; break; case GST_PHOTOGRAPHY_FOCUS_STATUS_NONE: break; case GST_PHOTOGRAPHY_FOCUS_STATUS_RUNNING: focusStatus = QCamera::Searching; break; default: break; } static int signalIndex = metaObject()->indexOfSlot( "_q_setFocusStatus(QCamera::LockStatus,QCamera::LockChangeReason)"); metaObject()->method(signalIndex).invoke(this, Qt::QueuedConnection, Q_ARG(QCamera::LockStatus,focusStatus), Q_ARG(QCamera::LockChangeReason,reason)); } }
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 void on_bus_element_cb (GstBus *bus, GstMessage *message, GbpPlayer *player) { const GstStructure *structure; const gchar *structure_name; GstElement *sink; structure = gst_message_get_structure (message); if (structure == NULL) return; structure_name = gst_structure_get_name (structure); #ifdef XP_MACOSX if (!strcmp (structure_name, "have-ns-view") || !strcmp (structure_name, "have-ca-layer")) { if (player->priv->xid != 0) { gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (GST_ELEMENT (message->src)), (gulong) player->priv->xid); } return; } #endif if (!strcmp (structure_name, "prepare-xwindow-id")) { sink = GST_ELEMENT (message->src); gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (sink), player->priv->xid); } }
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; }
static void code_received_cb (GstBus * bus, GstMessage * message, gpointer data) { KmsSendData *self = KMS_SEND_DATA (data); if (GST_MESSAGE_SRC (message) == GST_OBJECT (self->priv->zbar) && GST_MESSAGE_TYPE (message) == GST_MESSAGE_ELEMENT) { const GstStructure *st; guint64 ts; gchar *type, *symbol; st = gst_message_get_structure (message); if (g_strcmp0 (gst_structure_get_name (st), "barcode") != 0) { return; } if (!gst_structure_get (st, "timestamp", G_TYPE_UINT64, &ts, "type", G_TYPE_STRING, &type, "symbol", G_TYPE_STRING, &symbol, NULL)) { return; } kms_send_data_new_code (self, ts, type, symbol); g_free (type); g_free (symbol); } return; }
void pointerDetector_receive_message (GstBus *bus, GstMessage *message, gpointer pointerDetector) { const GstStructure *st; gchar *windowID; const gchar *type; std::string windowIDStr, typeStr; PointerDetectorFilter *filter = (PointerDetectorFilter *) pointerDetector; if (GST_MESSAGE_SRC (message) != GST_OBJECT (filter->pointerDetector) || GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT) return; st = gst_message_get_structure (message); type = gst_structure_get_name (st); if ( (g_strcmp0 (type, "window-out") != 0) && (g_strcmp0 (type, "window-in") != 0) ) { GST_WARNING ("The message does not have the correct name"); return; } if (!gst_structure_get (st, "window", G_TYPE_STRING , &windowID, NULL) ) { GST_WARNING ("The message does not contain the window ID"); return; } windowIDStr = windowID; typeStr = type; g_free (windowID); filter->raiseEvent (typeStr, windowIDStr); }
static gboolean check_message (GstMessage *message, FsSession *session, const gchar *message_name) { const GstStructure *s; const GValue *value; FsSession *message_session; if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT) return FALSE; s = gst_message_get_structure (message); if (!gst_structure_has_name (s, message_name)) return FALSE; value = gst_structure_get_value (s, "session"); if (!value || !G_VALUE_HOLDS (value, FS_TYPE_SESSION)) return FALSE; message_session = g_value_get_object (value); if (session != message_session) return FALSE; return TRUE; }
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 */ if (gst_element_set_state (pipeline, GST_STATE_PLAYING) != GST_STATE_CHANGE_ASYNC) { g_warning ("State change failed"); } } 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_callback (GstBus * bus, GstMessage * message, gpointer data) { switch (GST_MESSAGE_TYPE (message)) { case GST_MESSAGE_ERROR:{ 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); /* Write debug graph to file */ GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (camerabin), GST_DEBUG_GRAPH_SHOW_ALL, "camerabin.error"); g_main_loop_quit (loop); break; } case GST_MESSAGE_STATE_CHANGED: if (GST_IS_BIN (GST_MESSAGE_SRC (message))) { GstState oldstate, newstate; gst_message_parse_state_changed (message, &oldstate, &newstate, NULL); GST_DEBUG_OBJECT (GST_MESSAGE_SRC (message), "state-changed: %s -> %s", gst_element_state_get_name (oldstate), gst_element_state_get_name (newstate)); } break; case GST_MESSAGE_EOS: /* end-of-stream */ GST_INFO ("got eos() - should not happen"); g_main_loop_quit (loop); break; case GST_MESSAGE_ELEMENT: if (GST_MESSAGE_SRC (message) == (GstObject *) camerabin) { const GstStructure *structure = gst_message_get_structure (message); if (gst_structure_has_name (structure, "image-done")) { #ifndef GST_DISABLE_GST_DEBUG const gchar *fname = gst_structure_get_string (structure, "filename"); GST_DEBUG ("image done: %s", fname); #endif if (capture_count < capture_total) { g_idle_add ((GSourceFunc) run_pipeline, NULL); } else { g_main_loop_quit (loop); } } } break; default: /* unhandled message */ 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; }
bool ofxGstRTPServer::on_message(GstMessage * msg){ // read messages from the pipeline like dropped packages switch (GST_MESSAGE_TYPE (msg)) { case GST_MESSAGE_ELEMENT:{ GstObject * messageSrc = GST_MESSAGE_SRC(msg); ofLogVerbose(LOG_NAME) << "Got " << GST_MESSAGE_TYPE_NAME(msg) << " message from " << GST_MESSAGE_SRC_NAME(msg); ofLogVerbose(LOG_NAME) << "Message source type: " << G_OBJECT_CLASS_NAME(G_OBJECT_GET_CLASS(messageSrc)); ofLogVerbose(LOG_NAME) << "With structure name: " << gst_structure_get_name(gst_message_get_structure(msg)); ofLogVerbose(LOG_NAME) << gst_structure_to_string(gst_message_get_structure(msg)); return true; } case GST_MESSAGE_QOS:{ GstObject * messageSrc = GST_MESSAGE_SRC(msg); ofLogVerbose(LOG_NAME) << "Got " << GST_MESSAGE_TYPE_NAME(msg) << " message from " << GST_MESSAGE_SRC_NAME(msg); ofLogVerbose(LOG_NAME) << "Message source type: " << G_OBJECT_CLASS_NAME(G_OBJECT_GET_CLASS(messageSrc)); GstFormat format; guint64 processed; guint64 dropped; gst_message_parse_qos_stats(msg,&format,&processed,&dropped); ofLogVerbose(LOG_NAME) << "format " << gst_format_get_name(format) << " processed " << processed << " dropped " << dropped; gint64 jitter; gdouble proportion; gint quality; gst_message_parse_qos_values(msg,&jitter,&proportion,&quality); ofLogVerbose(LOG_NAME) << "jitter " << jitter << " proportion " << proportion << " quality " << quality; gboolean live; guint64 running_time; guint64 stream_time; guint64 timestamp; guint64 duration; gst_message_parse_qos(msg,&live,&running_time,&stream_time,×tamp,&duration); ofLogVerbose(LOG_NAME) << "live stream " << live << " runninng_time " << running_time << " stream_time " << stream_time << " timestamp " << timestamp << " duration " << duration; return true; } default: //ofLogVerbose(LOG_NAME) << "Got " << GST_MESSAGE_TYPE_NAME(msg) << " message from " << GST_MESSAGE_SRC_NAME(msg); return false; } }
static void fs_rtp_conference_handle_message ( GstBin * bin, GstMessage * message) { FsRtpConference *self = FS_RTP_CONFERENCE (bin); if (!self->gstrtpbin) return; switch (GST_MESSAGE_TYPE (message)) { case GST_MESSAGE_ELEMENT: { const GstStructure *s = gst_message_get_structure (message); /* we change the structure name and add the session ID to it */ if (gst_structure_has_name (s, "GstRTPBinSDES") && gst_structure_has_field_typed (s, "session", G_TYPE_UINT) && gst_structure_has_field_typed (s, "ssrc", G_TYPE_UINT) && gst_structure_has_field_typed (s, "cname", G_TYPE_STRING)) { guint session_id; guint ssrc; const GValue *val; FsRtpSession *session; const gchar *cname; val = gst_structure_get_value (s, "session"); session_id = g_value_get_uint (val); val = gst_structure_get_value (s, "ssrc"); ssrc = g_value_get_uint (val); cname = gst_structure_get_string (s, "cname"); session = fs_rtp_conference_get_session_by_id (self, session_id); if (session) { fs_rtp_session_associate_ssrc_cname (session, ssrc, cname); g_object_unref (session); } else { GST_WARNING_OBJECT (self,"Our GstRtpBin announced a new association" "for non-existent session %u for ssrc: %u and cname %s", session_id, ssrc, cname); } } /* fallthrough to forward the modified message to the parent */ } default: { GST_BIN_CLASS (parent_class)->handle_message (bin, message); break; } } }
static void element_message_cb (GstBus * bus, GstMessage * message, gpointer user_data) { gchar *s; s = gst_structure_to_string (gst_message_get_structure (message)); GST_DEBUG ("Received message: %s", s); g_free (s); messages++; }