static void gst_video_detect_post_message (GstVideoDetect * videodetect, GstBuffer * buffer, guint64 data) { GstBaseTransform *trans; GstMessage *m; guint64 duration, timestamp, running_time, stream_time; trans = GST_BASE_TRANSFORM_CAST (videodetect); /* get timestamps */ timestamp = GST_BUFFER_TIMESTAMP (buffer); duration = GST_BUFFER_DURATION (buffer); running_time = gst_segment_to_running_time (&trans->segment, GST_FORMAT_TIME, timestamp); stream_time = gst_segment_to_stream_time (&trans->segment, GST_FORMAT_TIME, timestamp); /* post message */ m = gst_message_new_element (GST_OBJECT_CAST (videodetect), gst_structure_new ("GstVideoDetect", "have-pattern", G_TYPE_BOOLEAN, videodetect->in_pattern, "timestamp", G_TYPE_UINT64, timestamp, "stream-time", G_TYPE_UINT64, stream_time, "running-time", G_TYPE_UINT64, running_time, "duration", G_TYPE_UINT64, duration, "data-uint64", G_TYPE_UINT64, data, "data", G_TYPE_UINT, (guint) MIN (data, G_MAXINT), NULL)); gst_element_post_message (GST_ELEMENT_CAST (videodetect), m); }
EXPORT_C #endif void gst_mixer_options_list_changed (GstMixer * mixer, GstMixerOptions * opts) { GstStructure *s; GstMessage *m; g_return_if_fail (mixer != NULL); g_return_if_fail (GST_IS_ELEMENT (mixer)); g_return_if_fail (opts != NULL); g_return_if_fail (GST_IS_MIXER_OPTIONS (opts)); /* we do not include the new list here on purpose, so that the application * has to use gst_mixer_options_get_values() to get the new list, which then * allows the mixer options object to update the internal GList in a somewhat * thread-safe way at least */ s = gst_structure_new (GST_MIXER_MESSAGE_NAME, "type", G_TYPE_STRING, "options-list-changed", "options", GST_TYPE_MIXER_OPTIONS, opts, NULL); m = gst_message_new_element (GST_OBJECT (mixer), s); if (gst_element_post_message (GST_ELEMENT (mixer), m) == FALSE) { GST_WARNING ("This element has no bus, therefore no message sent!"); } }
static VALUE element_initialize(VALUE self, VALUE src, VALUE structure) { G_INITIALIZE(self, gst_message_new_element(RVAL2GST_OBJ(src), RVAL2GST_STRUCT(structure))); return Qnil; }
static void _state_changed (FsStreamTransmitter *stream_transmitter, guint component, FsStreamState state, gpointer user_data) { FsRtpStream *self = FS_RTP_STREAM (user_data); FsRtpSession *session = fs_rtp_stream_get_session (self, NULL); GstElement *conf = NULL; if (!session) return; g_object_get (session, "conference", &conf, NULL); gst_element_post_message (conf, gst_message_new_element (GST_OBJECT (conf), gst_structure_new ("farstream-component-state-changed", "stream", FS_TYPE_STREAM, self, "component", G_TYPE_UINT, component, "state", FS_TYPE_STREAM_STATE, state, NULL))); gst_object_unref (conf); g_object_unref (session); if (component == 1 && state == FS_STREAM_STATE_FAILED) fs_stream_emit_error (FS_STREAM (self), FS_ERROR_CONNECTION_FAILED, "Could not establish connection on the RTP component"); }
static void gst_video_analyse_post_message (GstVideoAnalyse * videoanalyse, GstBuffer * buffer) { GstBaseTransform *trans; GstMessage *m; guint64 duration, timestamp, running_time, stream_time; trans = GST_BASE_TRANSFORM_CAST (videoanalyse); /* get timestamps */ timestamp = GST_BUFFER_TIMESTAMP (buffer); duration = GST_BUFFER_DURATION (buffer); running_time = gst_segment_to_running_time (&trans->segment, GST_FORMAT_TIME, timestamp); stream_time = gst_segment_to_stream_time (&trans->segment, GST_FORMAT_TIME, timestamp); m = gst_message_new_element (GST_OBJECT_CAST (videoanalyse), gst_structure_new ("GstVideoAnalyse", "timestamp", G_TYPE_UINT64, timestamp, "stream-time", G_TYPE_UINT64, stream_time, "running-time", G_TYPE_UINT64, running_time, "duration", G_TYPE_UINT64, duration, "brightness", G_TYPE_DOUBLE, videoanalyse->brightness, "brightness-variance", G_TYPE_DOUBLE, videoanalyse->brightness_var, NULL)); gst_element_post_message (GST_ELEMENT_CAST (videoanalyse), m); }
static void gst_progress_report_post_progress (GstProgressReport * filter, GstFormat format, gint64 current, gint64 total) { GstStructure *s = NULL; if (current >= 0 && total > 0) { gdouble perc; perc = gst_util_guint64_to_gdouble (current) * 100.0 / gst_util_guint64_to_gdouble (total); perc = CLAMP (perc, 0.0, 100.0); /* we provide a "percent" field of integer type to stay compatible * with qtdemux, but add a second "percent-double" field for those who * want more precision and are too lazy to calculate it themselves */ s = gst_structure_new ("progress", "percent", G_TYPE_INT, (gint) perc, "percent-double", G_TYPE_DOUBLE, perc, "current", G_TYPE_INT64, current, "total", G_TYPE_INT64, total, NULL); } else if (current >= 0) { s = gst_structure_new ("progress", "current", G_TYPE_INT64, current, NULL); } if (s) { GST_LOG_OBJECT (filter, "posting progress message: %" GST_PTR_FORMAT, s); gst_structure_set (s, "format", GST_TYPE_FORMAT, format, NULL); /* can't post it right here because we're holding the object lock */ filter->pending_msg = gst_message_new_element (GST_OBJECT_CAST (filter), s); } }
static void gst_dtmf_src_post_message (GstDTMFSrc * dtmfsrc, const gchar * message_name, GstDTMFSrcEvent * event) { GstStructure *s = NULL; switch (event->event_type) { case DTMF_EVENT_TYPE_START: s = gst_structure_new (message_name, "type", G_TYPE_INT, 1, "method", G_TYPE_INT, 2, "start", G_TYPE_BOOLEAN, TRUE, "number", G_TYPE_INT, event->event_number, "volume", G_TYPE_INT, event->volume, NULL); break; case DTMF_EVENT_TYPE_STOP: s = gst_structure_new (message_name, "type", G_TYPE_INT, 1, "method", G_TYPE_INT, 2, "start", G_TYPE_BOOLEAN, FALSE, NULL); break; case DTMF_EVENT_TYPE_PAUSE_TASK: return; } if (s) gst_element_post_message (GST_ELEMENT (dtmfsrc), gst_message_new_element (GST_OBJECT (dtmfsrc), s)); }
static void send_5app_1el_1err_2app_messages (guint interval_usecs) { GstMessage *m; GstStructure *s; gint i; for (i = 0; i < 5; i++) { s = gst_structure_new ("test_message", "msg_id", G_TYPE_INT, i, NULL); m = gst_message_new_application (NULL, s); GST_LOG ("posting application message"); gst_bus_post (test_bus, m); g_usleep (interval_usecs); } for (i = 0; i < 1; i++) { s = gst_structure_new ("test_message", "msg_id", G_TYPE_INT, i, NULL); m = gst_message_new_element (NULL, s); GST_LOG ("posting element message"); gst_bus_post (test_bus, m); g_usleep (interval_usecs); } for (i = 0; i < 1; i++) { m = gst_message_new_error (NULL, NULL, "debug string"); GST_LOG ("posting error message"); gst_bus_post (test_bus, m); g_usleep (interval_usecs); } for (i = 0; i < 2; i++) { s = gst_structure_new ("test_message", "msg_id", G_TYPE_INT, i, NULL); m = gst_message_new_application (NULL, s); GST_LOG ("posting application message"); gst_bus_post (test_bus, m); g_usleep (interval_usecs); } }
static void webKitMediaClearKeyDecryptorRequestDecryptionKey(WebKitMediaCommonEncryptionDecrypt* self, GstBuffer* initDataBuffer) { gst_element_post_message(GST_ELEMENT(self), gst_message_new_element(GST_OBJECT(self), gst_structure_new("drm-key-needed", "data", GST_TYPE_BUFFER, initDataBuffer, "key-system-id", G_TYPE_STRING, "org.w3.clearkey", nullptr))); }
static GstMessage * gst_dtmf_src_prepare_message (GstRTPDTMFSrc * dtmfsrc, const gchar * message_name, GstRTPDTMFSrcEvent * event) { GstStructure *s; switch (event->event_type) { case RTP_DTMF_EVENT_TYPE_START: s = gst_structure_new (message_name, "type", G_TYPE_INT, 1, "method", G_TYPE_INT, 1, "start", G_TYPE_BOOLEAN, TRUE, "number", G_TYPE_INT, event->payload->event, "volume", G_TYPE_INT, event->payload->volume, NULL); break; case RTP_DTMF_EVENT_TYPE_STOP: s = gst_structure_new (message_name, "type", G_TYPE_INT, 1, "method", G_TYPE_INT, 1, "start", G_TYPE_BOOLEAN, FALSE, NULL); break; case RTP_DTMF_EVENT_TYPE_PAUSE_TASK: return NULL; default: return NULL; } return gst_message_new_element (GST_OBJECT (dtmfsrc), s); }
static GstFlowReturn gst_compare_collect_pads (GstCollectPads2 * cpads, GstCompare * comp) { GstBuffer *buf1, *buf2; buf1 = gst_collect_pads2_pop (comp->cpads, gst_pad_get_element_private (comp->sinkpad)); buf2 = gst_collect_pads2_pop (comp->cpads, gst_pad_get_element_private (comp->checkpad)); if (!buf1 && !buf2) { gst_pad_push_event (comp->srcpad, gst_event_new_eos ()); return GST_FLOW_UNEXPECTED; } else if (buf1 && buf2) { gst_compare_buffers (comp, buf1, buf2); } else { GST_WARNING_OBJECT (comp, "buffer %p != NULL", buf1 ? buf1 : buf2); comp->count++; gst_element_post_message (GST_ELEMENT (comp), gst_message_new_element (GST_OBJECT (comp), gst_structure_new ("delta", "count", G_TYPE_INT, comp->count, NULL))); } if (buf1) gst_pad_push (comp->srcpad, buf1); if (buf2) gst_buffer_unref (buf2); return GST_FLOW_OK; }
/** * gst_missing_encoder_message_new: * @element: the #GstElement posting the message * @encode_caps: the (fixed) caps for which an encoder element is needed * * Creates a missing-plugin message for @element to notify the application * that an encoder element for a particular set of (fixed) caps is missing. * This function is mainly for use in plugins. * * Returns: (transfer full): a new #GstMessage, or NULL on error */ GstMessage * gst_missing_encoder_message_new (GstElement * element, const GstCaps * encode_caps) { GstStructure *s; GstCaps *caps; gchar *description; g_return_val_if_fail (element != NULL, NULL); g_return_val_if_fail (GST_IS_ELEMENT (element), NULL); g_return_val_if_fail (encode_caps != NULL, NULL); g_return_val_if_fail (GST_IS_CAPS (encode_caps), NULL); g_return_val_if_fail (!gst_caps_is_any (encode_caps), NULL); g_return_val_if_fail (!gst_caps_is_empty (encode_caps), NULL); g_return_val_if_fail (gst_caps_is_fixed (encode_caps), NULL); description = gst_pb_utils_get_encoder_description (encode_caps); caps = copy_and_clean_caps (encode_caps); s = gst_structure_new ("missing-plugin", "type", G_TYPE_STRING, "encoder", "detail", GST_TYPE_CAPS, caps, "name", G_TYPE_STRING, description, NULL); gst_caps_unref (caps); g_free (description); return gst_message_new_element (GST_OBJECT_CAST (element), s); }
static void _connection_failed (FsMsnConnection *connection, FsMsnStream *self) { FsMsnConference *conference = fs_msn_stream_get_conference (self, NULL); if (!conference) return; GST_OBJECT_LOCK (conference); self->priv->fd = -1; GST_OBJECT_UNLOCK (conference); gst_element_post_message (GST_ELEMENT (conference), gst_message_new_element (GST_OBJECT (conference), gst_structure_new ("farstream-component-state-changed", "stream", FS_TYPE_STREAM, self, "component", G_TYPE_UINT, 1, "state", FS_TYPE_STREAM_STATE, FS_STREAM_STATE_FAILED, NULL))); fs_stream_emit_error (FS_STREAM (self), FS_ERROR_CONNECTION_FAILED, "Could not establish streaming connection"); gst_object_unref (conference); }
static void _new_local_candidate ( FsStreamTransmitter *stream_transmitter, FsCandidate *candidate, gpointer user_data) { FsRtpStream *self = FS_RTP_STREAM (user_data); FsRtpSession *session = fs_rtp_stream_get_session (self, NULL); GstElement *conf = NULL; if (!session) return; g_object_get (session, "conference", &conf, NULL); gst_element_post_message (conf, gst_message_new_element (GST_OBJECT (conf), gst_structure_new ("farstream-new-local-candidate", "stream", FS_TYPE_STREAM, self, "candidate", FS_TYPE_CANDIDATE, candidate, NULL))); gst_object_unref (conf); g_object_unref (session); }
static gboolean gst_hls_demux_change_playlist (GstHLSDemux * demux, gboolean is_fast) { GList *list; GstStructure *s; if (is_fast) list = g_list_next (demux->client->main->current_variant); else list = g_list_previous (demux->client->main->current_variant); /* Don't do anything else if the playlist is the same */ if (!list || list->data == demux->client->current) return TRUE; demux->client->main->current_variant = list; gst_m3u8_client_set_current (demux->client, list->data); gst_hls_demux_update_playlist (demux, TRUE); GST_INFO_OBJECT (demux, "Client is %s, switching to bitrate %d", is_fast ? "fast" : "slow", demux->client->current->bandwidth); s = gst_structure_new ("playlist", "uri", G_TYPE_STRING, demux->client->current->uri, "bitrate", G_TYPE_INT, demux->client->current->bandwidth, NULL); gst_element_post_message (GST_ELEMENT_CAST (demux), gst_message_new_element (GST_OBJECT_CAST (demux), s)); /* Force typefinding since we might have changed media type */ demux->do_typefind = TRUE; return TRUE; }
static GstFlowReturn gst_gdk_pixbuf_sink_handle_buffer (GstBaseSink * basesink, GstBuffer * buf, const gchar * msg_name) { GstGdkPixbufSink *sink; GdkPixbuf *pixbuf; gboolean do_post; sink = GST_GDK_PIXBUF_SINK (basesink); pixbuf = gst_gdk_pixbuf_sink_get_pixbuf_from_buffer (sink, buf); GST_OBJECT_LOCK (sink); do_post = sink->post_messages; if (sink->last_pixbuf) g_object_unref (sink->last_pixbuf); sink->last_pixbuf = pixbuf; /* take ownership */ GST_OBJECT_UNLOCK (sink); if (G_UNLIKELY (pixbuf == NULL)) goto error; if (do_post) { GstStructure *s; GstMessage *msg; /* it's okay to keep using pixbuf here, we can be sure no one is going to * unref or change sink->last_pixbuf before we return from this function. * The structure will take its own ref to the pixbuf. */ s = gst_structure_new (msg_name, "pixbuf", GDK_TYPE_PIXBUF, pixbuf, "pixel-aspect-ratio", GST_TYPE_FRACTION, sink->par_d, sink->par_n, NULL); msg = gst_message_new_element (GST_OBJECT_CAST (sink), s); gst_element_post_message (GST_ELEMENT_CAST (sink), msg); } g_object_notify (G_OBJECT (sink), "last-pixbuf"); return GST_FLOW_OK; /* ERRORS */ error: { /* This shouldn't really happen */ GST_ELEMENT_ERROR (sink, LIBRARY, FAILED, ("Couldn't create pixbuf from RGB image."), ("Probably not enough free memory")); return GST_FLOW_ERROR; } }
static GstMessage * gst_aubio_tempo_message_new(GstAubioTempo *a, GstClockTime beat) { GstStructure *s; s = gst_structure_new("aubiotempo", "beat", GST_TYPE_CLOCK_TIME, beat , "bpm" , G_TYPE_DOUBLE , a->bpm, NULL); return gst_message_new_element (GST_OBJECT (a), s); }
static GstMessage * gst_cutter_message_new (GstCutter * c, gboolean above, GstClockTime timestamp) { GstStructure *s; s = gst_structure_new ("cutter", "above", G_TYPE_BOOLEAN, above, "timestamp", GST_TYPE_CLOCK_TIME, timestamp, NULL); return gst_message_new_element (GST_OBJECT (c), s); }
static void gst_identity_check_imperfect_timestamp (GstIdentity * identity, GstBuffer * buf) { GstClockTime timestamp = GST_BUFFER_TIMESTAMP (buf); /* invalid timestamp drops us out of check. FIXME: maybe warn ? */ if (timestamp != GST_CLOCK_TIME_NONE) { /* check if we had a previous buffer to compare to */ if (identity->prev_timestamp != GST_CLOCK_TIME_NONE && identity->prev_duration != GST_CLOCK_TIME_NONE) { GstClockTime t_expected; GstClockTimeDiff dt; t_expected = identity->prev_timestamp + identity->prev_duration; dt = GST_CLOCK_DIFF (t_expected, timestamp); if (dt != 0) { /* * "imperfect-timestamp" bus message: * @identity: the identity instance * @delta: the GST_CLOCK_DIFF to the prev timestamp * @prev-timestamp: the previous buffer timestamp * @prev-duration: the previous buffer duration * @prev-offset: the previous buffer offset * @prev-offset-end: the previous buffer offset end * @cur-timestamp: the current buffer timestamp * @cur-duration: the current buffer duration * @cur-offset: the current buffer offset * @cur-offset-end: the current buffer offset end * * This bus message gets emitted if the check-imperfect-timestamp * property is set and there is a gap in time between the * last buffer and the newly received buffer. */ gst_element_post_message (GST_ELEMENT (identity), gst_message_new_element (GST_OBJECT (identity), gst_structure_new ("imperfect-timestamp", "delta", G_TYPE_INT64, dt, "prev-timestamp", G_TYPE_UINT64, identity->prev_timestamp, "prev-duration", G_TYPE_UINT64, identity->prev_duration, "prev-offset", G_TYPE_UINT64, identity->prev_offset, "prev-offset-end", G_TYPE_UINT64, identity->prev_offset_end, "cur-timestamp", G_TYPE_UINT64, timestamp, "cur-duration", G_TYPE_UINT64, GST_BUFFER_DURATION (buf), "cur-offset", G_TYPE_UINT64, GST_BUFFER_OFFSET (buf), "cur-offset-end", G_TYPE_UINT64, GST_BUFFER_OFFSET_END (buf), NULL))); } } else { GST_DEBUG_OBJECT (identity, "can't check data-contiguity, no " "offset_end was set on previous buffer"); } } }
static void gst_compare_buffers (GstCompare * comp, GstBuffer * buf1, GstCaps * caps1, GstBuffer * buf2, GstCaps * caps2) { gdouble delta = 0; gsize size1, size2; /* first check metadata */ gst_compare_meta (comp, buf1, caps1, buf2, caps2); size1 = gst_buffer_get_size (buf1); size2 = gst_buffer_get_size (buf1); /* check content according to method */ /* but at least size should match */ if (size1 != size2) { delta = comp->threshold + 1; } else { GstMapInfo map1, map2; gst_buffer_map (buf1, &map1, GST_MAP_READ); gst_buffer_map (buf2, &map2, GST_MAP_READ); GST_MEMDUMP_OBJECT (comp, "buffer 1", map1.data, map2.size); GST_MEMDUMP_OBJECT (comp, "buffer 2", map2.data, map2.size); gst_buffer_unmap (buf1, &map1); gst_buffer_unmap (buf2, &map2); switch (comp->method) { case GST_COMPARE_METHOD_MEM: delta = gst_compare_mem (comp, buf1, caps1, buf2, caps2); break; case GST_COMPARE_METHOD_MAX: delta = gst_compare_max (comp, buf1, caps1, buf2, caps2); break; case GST_COMPARE_METHOD_SSIM: delta = gst_compare_ssim (comp, buf1, caps1, buf2, caps2); break; default: g_assert_not_reached (); break; } } if ((comp->upper && delta > comp->threshold) || (!comp->upper && delta < comp->threshold)) { GST_WARNING_OBJECT (comp, "buffers %p and %p failed content match %f", buf1, buf2, delta); gst_element_post_message (GST_ELEMENT (comp), gst_message_new_element (GST_OBJECT (comp), gst_structure_new ("delta", "content", G_TYPE_DOUBLE, delta, NULL))); } }
static void kms_crowd_detector_send_message_direction (KmsCrowdDetector * crowddetector, double angle, int curve) { GstStructure *s; GstMessage *m; s = gst_structure_new ("direction-event", "roi", G_TYPE_STRING, crowddetector->priv->rois_data[curve].name, "direction_angle", G_TYPE_DOUBLE, angle, NULL); m = gst_message_new_element (GST_OBJECT (crowddetector), s); gst_element_post_message (GST_ELEMENT (crowddetector), m); }
static GInputStream * gst_gio_src_get_stream (GstGioBaseSrc * bsrc) { GstGioSrc *src = GST_GIO_SRC (bsrc); GError *err = NULL; GInputStream *stream; GCancellable *cancel = bsrc->cancel; gchar *uri = NULL; if (src->file == NULL) { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("No location or GFile given")); return NULL; } uri = g_file_get_uri (src->file); if (!uri) uri = g_strdup ("(null)"); stream = G_INPUT_STREAM (g_file_read (src->file, cancel, &err)); if (stream == NULL && !gst_gio_error (src, "g_file_read", &err, NULL)) { if (GST_GIO_ERROR_MATCHES (err, NOT_FOUND)) { GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, (NULL), ("Could not open location %s for reading: %s", uri, err->message)); } else if (GST_GIO_ERROR_MATCHES (err, NOT_MOUNTED)) { gst_element_post_message (GST_ELEMENT_CAST (src), gst_message_new_element (GST_OBJECT_CAST (src), gst_structure_new ("not-mounted", "file", G_TYPE_FILE, src->file, "uri", G_TYPE_STRING, uri, NULL))); GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Location %s not mounted: %s", uri, err->message)); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Could not open location %s for reading: %s", uri, err->message)); } g_free (uri); g_clear_error (&err); return NULL; } else if (stream == NULL) { g_free (uri); return NULL; } GST_DEBUG_OBJECT (src, "opened location %s", uri); g_free (uri); return stream; }
/** * gst_video_overlay_prepare_window_handle: * @overlay: a #GstVideoOverlay which does not yet have an Window handle set * * This will post a "prepare-window-handle" element message on the bus * to give applications an opportunity to call * gst_video_overlay_set_window_handle() before a plugin creates its own * window. * * This function should only be used by video overlay plugin developers. */ void gst_video_overlay_prepare_window_handle (GstVideoOverlay * overlay) { GstStructure *s; GstMessage *msg; g_return_if_fail (overlay != NULL); g_return_if_fail (GST_IS_VIDEO_OVERLAY (overlay)); GST_LOG_OBJECT (GST_OBJECT (overlay), "prepare window handle"); s = gst_structure_new_empty ("prepare-window-handle"); msg = gst_message_new_element (GST_OBJECT (overlay), s); gst_element_post_message (GST_ELEMENT (overlay), msg); }
/** * gst_x_overlay_prepare_xwindow_id: * @overlay: a #GstXOverlay which does not yet have an XWindow. * * This will post a "prepare-xwindow-id" element message on the bus * to give applications an opportunity to call * gst_x_overlay_set_xwindow_id() before a plugin creates its own * window. * * This function should only be used by video overlay plugin developers. */ void gst_x_overlay_prepare_xwindow_id (GstXOverlay * overlay) { GstStructure *s; GstMessage *msg; g_return_if_fail (overlay != NULL); g_return_if_fail (GST_IS_X_OVERLAY (overlay)); GST_LOG_OBJECT (GST_OBJECT (overlay), "prepare xwindow_id"); s = gst_structure_new ("prepare-xwindow-id", NULL); msg = gst_message_new_element (GST_OBJECT (overlay), s); gst_element_post_message (GST_ELEMENT (overlay), msg); }
static void gst_sphinx_sink_send_message (GstSphinxSink *sphinxsink, gchar *message, gchar *text) { GstStructure *s; GstMessage *msg; if (text) s = gst_structure_new (message, "text", G_TYPE_STRING, text, NULL); else s = gst_structure_new (message, NULL); msg = gst_message_new_element (GST_OBJECT (sphinxsink), s); gst_element_post_message (GST_ELEMENT (sphinxsink), msg); }
/* * When an ieee1394 bus reset happens, usually a device has been removed * or added. We send a message on the message bus with the node count * and whether the capture device used in this element connected, disconnected * or was unchanged * Message structure: * nodecount - integer with number of nodes on bus * current-device-change - integer (1 if device connected, 0 if no change to * current device status, -1 if device disconnected) */ static int gst_hdv1394src_bus_reset (raw1394handle_t handle, unsigned int generation) { GstHDV1394Src *src; gint nodecount; GstMessage *message; GstStructure *structure; gint current_device_change; gint i; src = gst_hdv1394src_from_raw1394handle (handle); GST_INFO_OBJECT (src, "have bus reset"); /* update generation - told to do so by docs */ raw1394_update_generation (handle, generation); nodecount = raw1394_get_nodecount (handle); /* allocate memory for portinfo */ /* current_device_change is -1 if camera disconnected, 0 if other device * connected or 1 if camera has now connected */ current_device_change = -1; for (i = 0; i < nodecount; i++) { if (src->guid == rom1394_get_guid (handle, i)) { /* Camera is with us */ GST_DEBUG ("Camera is with us"); if (!src->connected) { current_device_change = 1; src->connected = TRUE; } else current_device_change = 0; } } if (src->connected && current_device_change == -1) { GST_DEBUG ("Camera has disconnected"); src->connected = FALSE; } else if (!src->connected && current_device_change == -1) { GST_DEBUG ("Camera is still not with us"); current_device_change = 0; } structure = gst_structure_new ("ieee1394-bus-reset", "nodecount", G_TYPE_INT, nodecount, "current-device-change", G_TYPE_INT, current_device_change, NULL); message = gst_message_new_element (GST_OBJECT (src), structure); gst_element_post_message (GST_ELEMENT (src), message); return 0; }
static void kms_crowd_detector_send_message_fluidity (KmsCrowdDetector * crowddetector, double fluidity_percentage, int curve) { GstStructure *s; GstMessage *m; s = gst_structure_new ("fluidity-event", "roi", G_TYPE_STRING, crowddetector->priv->rois_data[curve].name, "fluidity_percentage", G_TYPE_DOUBLE, fluidity_percentage, "fluidity_level", G_TYPE_INT, crowddetector->priv->rois_data[curve].actual_fluidity_level, NULL); m = gst_message_new_element (GST_OBJECT (crowddetector), s); gst_element_post_message (GST_ELEMENT (crowddetector), m); }
/** * gst_x_overlay_got_xwindow_id: * @overlay: a #GstXOverlay which got a XWindow. * @xwindow_id: a #XID referencing the XWindow. * * This will post a "have-xwindow-id" element message on the bus. * * This function should only be used by video overlay plugin developers. */ void gst_x_overlay_got_xwindow_id (GstXOverlay * overlay, gulong xwindow_id) { GstStructure *s; GstMessage *msg; g_return_if_fail (overlay != NULL); g_return_if_fail (GST_IS_X_OVERLAY (overlay)); GST_LOG_OBJECT (GST_OBJECT (overlay), "xwindow_id = %lu", xwindow_id); s = gst_structure_new ("have-xwindow-id", "xwindow-id", G_TYPE_ULONG, xwindow_id, NULL); msg = gst_message_new_element (GST_OBJECT (overlay), s); gst_element_post_message (GST_ELEMENT (overlay), msg); }
static GstMessage * gst_spectrum_message_new (GstSpectrum * spectrum, GstClockTime endtime) { GstStructure *s; GValue v = { 0, }; GValue *l; guint i; gfloat *spect_magnitude = spectrum->spect_magnitude; gfloat *spect_phase = spectrum->spect_phase; GST_DEBUG_OBJECT (spectrum, "preparing message, spect = %p, bands =%d ", spect_magnitude, spectrum->bands); s = gst_structure_new ("spectrum", "endtime", GST_TYPE_CLOCK_TIME, endtime, NULL); if (spectrum->message_magnitude) { g_value_init (&v, GST_TYPE_LIST); /* will copy-by-value */ gst_structure_set_value (s, "magnitude", &v); g_value_unset (&v); g_value_init (&v, G_TYPE_FLOAT); l = (GValue *) gst_structure_get_value (s, "magnitude"); for (i = 0; i < spectrum->bands; i++) { g_value_set_float (&v, spect_magnitude[i]); gst_value_list_append_value (l, &v); /* copies by value */ } g_value_unset (&v); } if (spectrum->message_phase) { g_value_init (&v, GST_TYPE_LIST); /* will copy-by-value */ gst_structure_set_value (s, "phase", &v); g_value_unset (&v); g_value_init (&v, G_TYPE_FLOAT); l = (GValue *) gst_structure_get_value (s, "phase"); for (i = 0; i < spectrum->bands; i++) { g_value_set_float (&v, spect_phase[i]); gst_value_list_append_value (l, &v); /* copies by value */ } g_value_unset (&v); } return gst_message_new_element (GST_OBJECT (spectrum), s); }
static GstFlowReturn gst_dvbsrc_create (GstPushSrc * element, GstBuffer ** buf) { gint buffer_size; GstFlowReturn retval = GST_FLOW_ERROR; GstDvbSrc *object; object = GST_DVBSRC (element); GST_LOG ("fd_dvr: %d", object->fd_dvr); //g_object_get(G_OBJECT(object), "blocksize", &buffer_size, NULL); buffer_size = DEFAULT_BUFFER_SIZE; /* device can not be tuned during read */ g_mutex_lock (object->tune_mutex); if (object->fd_dvr > -1) { /* --- Read TS from DVR device --- */ GST_DEBUG_OBJECT (object, "Reading from DVR device"); *buf = read_device (object->fd_dvr, object->adapter_number, object->frontend_number, buffer_size, object); if (*buf != NULL) { GstCaps *caps; retval = GST_FLOW_OK; caps = gst_pad_get_caps (GST_BASE_SRC_PAD (object)); gst_buffer_set_caps (*buf, caps); gst_caps_unref (caps); } else { GST_DEBUG_OBJECT (object, "Failed to read from device"); gst_element_post_message (GST_ELEMENT_CAST (object), gst_message_new_element (GST_OBJECT (object), gst_structure_empty_new ("dvb-read-failure"))); } if (object->stats_interval != 0 && ++object->stats_counter == object->stats_interval) { gst_dvbsrc_output_frontend_stats (object); object->stats_counter = 0; } } g_mutex_unlock (object->tune_mutex); return retval; }