void kms_pointer_detector_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) { KmsPointerDetector *pointerdetector = KMS_POINTER_DETECTOR (object); GST_DEBUG_OBJECT (pointerdetector, "get_property"); switch (property_id) { case PROP_NUM_REGIONS: g_value_set_int (value, pointerdetector->numOfRegions); break; case PROP_WINDOW_SCALE: g_value_set_int (value, pointerdetector->windowScaleRef); break; case PROP_SHOW_DEBUG_INFO: g_value_set_boolean (value, pointerdetector->show_debug_info); break; case PROP_WINDOWS_LAYOUT: if (pointerdetector->buttonsLayout == NULL) { pointerdetector->buttonsLayout = gst_structure_new_empty ("windows"); } g_value_set_boxed (value, pointerdetector->buttonsLayout); break; case PROP_MESSAGE: g_value_set_boolean (value, pointerdetector->putMessage); break; case PROP_SHOW_WINDOWS_LAYOUT: g_value_set_boolean (value, pointerdetector->show_windows_layout); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void kms_image_overlay_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) { KmsImageOverlay *imageoverlay = KMS_IMAGE_OVERLAY (object); GST_DEBUG_OBJECT (imageoverlay, "get_property"); GST_OBJECT_LOCK (imageoverlay); switch (property_id) { case PROP_SHOW_DEBUG_INFO: g_value_set_boolean (value, imageoverlay->priv->show_debug_info); break; case PROP_IMAGE_TO_OVERLAY: if (imageoverlay->priv->image_to_overlay == NULL) { imageoverlay->priv->image_to_overlay = gst_structure_new_empty ("image_to_overlay"); } g_value_set_boxed (value, imageoverlay->priv->image_to_overlay); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } GST_OBJECT_UNLOCK (imageoverlay); }
static GstStructure * kms_element_stats_impl (KmsElement * self, gchar * selector) { GstStructure *stats; stats = gst_structure_new_empty ("stats"); if (self->priv->stats_enabled) { GstStructure *e_stats; /* Video and audio latencies are measured in nano seconds. They */ /* are such an small values so there is no harm in casting them */ /* to uint64 even we might lose a bit of preccision. */ e_stats = gst_structure_new (KMS_ELEMENT_STATS_STRUCT_NAME, "input-video-latency", G_TYPE_UINT64, (guint64) self->priv->stats.vi, "input-audio-latency", G_TYPE_UINT64, (guint64) self->priv->stats.ai, NULL); gst_structure_set (stats, KMS_MEDIA_ELEMENT_FIELD, GST_TYPE_STRUCTURE, e_stats, NULL); gst_structure_free (e_stats); } return stats; }
/* This function is called when new metadata is discovered in the stream */ static void tags_cb (GstElement *playbin, gint stream, CustomData *data) { /* We are possibly in a GStreamer working thread, so we notify the main * thread of this event through a message in the bus */ gst_element_post_message (playbin, gst_message_new_application (GST_OBJECT (playbin), gst_structure_new_empty ("tags-changed"))); }
static GByteArray * setup_test_variables (GstHlsDemuxTestInputData * inputTestData, GstAdaptiveDemuxTestExpectedOutput * outputTestData, GstHlsDemuxTestCase * hlsTestCase, GstAdaptiveDemuxTestCase * engineTestData, guint segment_size) { GByteArray *mpeg_ts = NULL; if (segment_size) { mpeg_ts = generate_transport_stream ((segment_size)); fail_unless (mpeg_ts != NULL); for (guint itd = 0; inputTestData[itd].uri; ++itd) { if (g_str_has_suffix (inputTestData[itd].uri, ".ts")) { inputTestData[itd].payload = mpeg_ts->data; } } for (guint otd = 0; outputTestData[otd].name; ++otd) { outputTestData[otd].expected_data = mpeg_ts->data; engineTestData->output_streams = g_list_append (engineTestData->output_streams, &outputTestData[otd]); } } hlsTestCase->input = inputTestData; hlsTestCase->state = gst_structure_new_empty (__FUNCTION__); return mpeg_ts; }
/** * send_underrun_message * * Sends UNDERRUN message to the bus. */ static void send_underrun_message(ProgressBuffer* element) { GstStructure *s = gst_structure_new_empty(PB_MESSAGE_UNDERRUN); GstMessage *msg = gst_message_new_application(GST_OBJECT(element), s); gst_element_post_message(GST_ELEMENT(element), msg); }
GstStructure * gst_multiudpsink_get_stats (GstMultiUDPSink * sink, const gchar * host, gint port) { GstUDPClient *client; GstStructure *result = NULL; GstUDPClient udpclient; GList *find; udpclient.host = (gchar *) host; udpclient.port = port; g_mutex_lock (&sink->client_lock); find = g_list_find_custom (sink->clients, &udpclient, (GCompareFunc) client_compare); if (!find) goto not_found; GST_DEBUG_OBJECT (sink, "stats for client with host %s, port %d", host, port); client = (GstUDPClient *) find->data; result = gst_structure_new_empty ("multiudpsink-stats"); gst_structure_set (result, "bytes-sent", G_TYPE_UINT64, client->bytes_sent, "packets-sent", G_TYPE_UINT64, client->packets_sent, "connect-time", G_TYPE_UINT64, client->connect_time, "disconnect-time", G_TYPE_UINT64, client->disconnect_time, NULL); g_mutex_unlock (&sink->client_lock); return result; /* ERRORS */ not_found: { g_mutex_unlock (&sink->client_lock); GST_WARNING_OBJECT (sink, "client with host %s, port %d not found", host, port); /* Apparently (see comment in gstmultifdsink.c) returning NULL from here may * confuse/break python bindings */ return gst_structure_new_empty ("multiudpsink-stats"); } }
static GstStructure * get_structure_from_roi (std::shared_ptr<RegionOfInterest> roi) { GstStructure *roiStructure, *configRoiSt; std::shared_ptr<RegionOfInterestConfig> config; int pointCount = 0; roiStructure = gst_structure_new_empty (roi->getId().c_str() ); if (roiStructure == NULL) { throw KurentoException (MEDIA_OBJECT_ILLEGAL_PARAM_ERROR, "Invalid roi name"); } for (std::shared_ptr<RelativePoint> point : roi->getPoints() ) { GstStructure *pointSt; std::string name = "point" + std::to_string (pointCount ++); pointSt = gst_structure_new (name.c_str(), "x", G_TYPE_FLOAT, point->getX(), "y", G_TYPE_FLOAT, point->getY(), NULL); gst_structure_set (roiStructure, name.c_str(), GST_TYPE_STRUCTURE, pointSt, NULL); gst_structure_free (pointSt); } config = roi->getRegionOfInterestConfig(); configRoiSt = gst_structure_new ("config", "id", G_TYPE_STRING, roi->getId().c_str(), "occupancy_level_min", G_TYPE_INT, config->getOccupancyLevelMin(), "occupancy_level_med", G_TYPE_INT, config->getOccupancyLevelMed(), "occupancy_level_max", G_TYPE_INT, config->getOccupancyLevelMax(), "occupancy_num_frames_to_event", G_TYPE_INT, config->getOccupancyNumFramesToEvent(), "fluidity_level_min", G_TYPE_INT, config->getFluidityLevelMin(), "fluidity_level_med", G_TYPE_INT, config->getFluidityLevelMed(), "fluidity_level_max", G_TYPE_INT, config->getFluidityLevelMax(), "fluidity_num_frames_to_event", G_TYPE_INT, config->getFluidityNumFramesToEvent(), "send_optical_flow_event", G_TYPE_BOOLEAN, config->getSendOpticalFlowEvent(), "optical_flow_num_frames_to_event", G_TYPE_INT, config->getOpticalFlowNumFramesToEvent(), "optical_flow_num_frames_to_reset", G_TYPE_INT, config->getOpticalFlowNumFramesToReset(), "optical_flow_angle_offset", G_TYPE_INT, config->getOpticalFlowAngleOffset(), NULL); gst_structure_set (roiStructure, "config", GST_TYPE_STRUCTURE, configRoiSt, NULL); gst_structure_free (configRoiSt); return roiStructure; }
void PointerDetectorFilter::clearWindows() { GstStructure *buttonsLayout; buttonsLayout = gst_structure_new_empty ("buttonsLayout"); g_object_set (G_OBJECT (this->pointerDetector), WINDOWS_LAYOUT, buttonsLayout, NULL); gst_structure_free (buttonsLayout); }
GstQuery * gst_droid_query_new_video_color_format () { GstQuery *query; GstStructure *structure; structure = gst_structure_new_empty (GST_DROID_VIDEO_COLOR_FORMAT_QUERY_NAME); query = gst_query_new_custom (GST_QUERY_CUSTOM, structure); return query; }
static void append_codec_to_array (GArray *array, const char *codec) { GValue v = G_VALUE_INIT; GstStructure *s; g_value_init (&v, GST_TYPE_STRUCTURE); s = gst_structure_new_empty (codec); gst_value_set_structure (&v, s); gst_structure_free (s); g_array_append_val (array, v); }
/* * This function sends a dummy event to force blocked probe to be called */ static void send_dummy_event (GstPad * pad, const gchar * name) { GstElement *parent = gst_pad_get_parent_element (pad); if (parent == NULL) { return; } if (GST_PAD_IS_SINK (pad)) { gst_pad_send_event (pad, gst_event_new_custom (GST_EVENT_TYPE_DOWNSTREAM | GST_EVENT_TYPE_SERIALIZED, gst_structure_new_empty (name))); } else { gst_pad_send_event (pad, gst_event_new_custom (GST_EVENT_TYPE_UPSTREAM | GST_EVENT_TYPE_SERIALIZED, gst_structure_new_empty (name))); } g_object_unref (parent); }
/** * gst_rtsp_token_new_empty: * * Create a new empty Authorization token. * * Returns: (transfer full): a new empty authorization token. */ GstRTSPToken * gst_rtsp_token_new_empty (void) { GstRTSPTokenImpl *token; GstStructure *s; s = gst_structure_new_empty ("GstRTSPToken"); g_return_val_if_fail (s != NULL, NULL); token = g_slice_new0 (GstRTSPTokenImpl); gst_rtsp_token_init (token, s); return (GstRTSPToken *) token; }
static GstStructure * kms_element_get_e2e_latency_stats (KmsRecorderEndpoint * self, gchar * selector) { gpointer key, value; GHashTableIter iter; GstStructure *stats; stats = gst_structure_new_empty ("e2e-latencies"); KMS_ELEMENT_LOCK (self); g_hash_table_iter_init (&iter, self->priv->stats.avg_e2e); while (g_hash_table_iter_next (&iter, &key, &value)) { StreamE2EAvgStat *avg = value; GstStructure *pad_latency; gchar *padname, *id = key; if (selector != NULL && ((g_strcmp0 (selector, AUDIO_STREAM_NAME) == 0 && avg->type != KMS_MEDIA_TYPE_AUDIO) || (g_strcmp0 (selector, VIDEO_STREAM_NAME) == 0 && avg->type != KMS_MEDIA_TYPE_VIDEO))) { continue; } padname = kms_element_get_padname_from_id (self, id); if (padname == NULL) { GST_WARNING_OBJECT (self, "No pad identified by %s", id); continue; } /* Video and audio latencies are measured in nano seconds. They */ /* are such an small values so there is no harm in casting them */ /* to uint64 even we might lose a bit of preccision. */ pad_latency = gst_structure_new (padname, "type", G_TYPE_STRING, (avg->type == KMS_MEDIA_TYPE_AUDIO) ? AUDIO_STREAM_NAME : VIDEO_STREAM_NAME, "avg", G_TYPE_UINT64, (guint64) avg->avg, NULL); gst_structure_set (stats, padname, GST_TYPE_STRUCTURE, pad_latency, NULL); gst_structure_free (pad_latency); g_free (padname); } KMS_ELEMENT_UNLOCK (self); return stats; }
/** * 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_event_new_tag: * @taglist: (transfer full): metadata list. The event will take ownership * of the taglist. * * Generates a metadata tag event from the given @taglist. * * The scope of the taglist specifies if the taglist applies to the * complete medium or only to this specific stream. As the tag event * is a sticky event, elements should merge tags received from * upstream with a given scope with their own tags with the same * scope and create a new tag event from it. * * Returns: (transfer full): a new #GstEvent */ GstEvent * gst_event_new_tag (GstTagList * taglist) { GstStructure *s; GValue val = G_VALUE_INIT; const gchar *names[] = { "GstTagList-stream", "GstTagList-global" }; g_return_val_if_fail (taglist != NULL, NULL); s = gst_structure_new_empty (names[gst_tag_list_get_scope (taglist)]); g_value_init (&val, GST_TYPE_TAG_LIST); g_value_take_boxed (&val, taglist); gst_structure_id_take_value (s, GST_QUARK (TAGLIST), &val); return gst_event_new_custom (GST_EVENT_TAG, s); }
/** * gst_tracer_record_new: * @name: name of new record, must end on ".class". * @firstfield: name of first field to set * @...: additional arguments * * Create a new tracer record. The record instance can be used to efficiently * log entries using gst_tracer_record_log(). * * The @name without the ".class" suffix will be used for the log records. * There must be fields for each value that gets logged where the field name is * the value name. The field must be a #GstStructure describing the value. The * sub structure must contain a field called 'type' of %G_TYPE_GTYPE that * contains the GType of the value. The resulting #GstTracerRecord will take * ownership of the field structures. * * The way to deal with optional values is to log an additional boolean before * the optional field, that if %TRUE signals that the optional field is valid * and %FALSE signals that the optional field should be ignored. One must still * log a placeholder value for the optional field though. Please also note, that * pointer type values must not be NULL - the underlying serialisation can not * handle that right now. * * > Please note that this is still under discussion and subject to change. * * Returns: (transfer full): a new #GstTracerRecord */ GstTracerRecord * gst_tracer_record_new (const gchar * name, const gchar * firstfield, ...) { GstTracerRecord *self; GstStructure *structure; va_list varargs; gchar *err = NULL; GType type; GQuark id; va_start (varargs, firstfield); structure = gst_structure_new_empty (name); while (firstfield) { GValue val = { 0, }; id = g_quark_from_string (firstfield); type = va_arg (varargs, GType); /* all fields passed here must be GstStructures which we take over */ if (type != GST_TYPE_STRUCTURE) { GST_WARNING ("expected field of type GstStructure, but %s is %s", firstfield, g_type_name (type)); } G_VALUE_COLLECT_INIT (&val, type, varargs, G_VALUE_NOCOPY_CONTENTS, &err); if (G_UNLIKELY (err)) { g_critical ("%s", err); break; } /* see boxed_proxy_collect_value */ val.data[1].v_uint &= ~G_VALUE_NOCOPY_CONTENTS; gst_structure_id_take_value (structure, id, &val); firstfield = va_arg (varargs, gchar *); } va_end (varargs); self = g_object_new (GST_TYPE_TRACER_RECORD, NULL); /* Clear floating flag */ gst_object_ref_sink (self); self->spec = structure; gst_tracer_record_build_format (self); return self; }
static void do_post_message_pre (GstStatsTracer * self, guint64 ts, GstElement * elem, GstMessage * msg) { GstElementStats *stats = get_element_stats (self, elem); const GstStructure *msg_s = gst_message_get_structure (msg); GstStructure *s = msg_s ? (GstStructure *) msg_s : gst_structure_new_empty ("dummy"); stats->last_ts = ts; /* FIXME: work out whether using NULL instead of a dummy struct would work */ gst_tracer_record_log (tr_message, (guint64) (guintptr) g_thread_self (), ts, stats->index, GST_MESSAGE_TYPE_NAME (msg), s); if (s != msg_s) gst_structure_free (s); }
static void gst_droidcamsrc_dev_shutter_callback (void *user) { GstDroidCamSrcDev *dev = (GstDroidCamSrcDev *) user; GstDroidCamSrc *src = GST_DROIDCAMSRC (GST_PAD_PARENT (dev->imgsrc->pad)); GST_DEBUG_OBJECT (src, "dev shutter callback"); g_rec_mutex_lock (dev->lock); if (!dev->img->image_start_sent) { gst_droidcamsrc_post_message (src, gst_structure_new_empty (GST_DROIDCAMSRC_CAPTURE_START)); dev->img->image_start_sent = TRUE; } g_rec_mutex_unlock (dev->lock); }
static GstCaps * gst_gdk_pixbuf_dec_get_capslist (GstCaps * filter) { GSList *slist; GSList *slist0; GstCaps *capslist = NULL; GstCaps *return_caps = NULL; GstCaps *tmpl_caps; capslist = gst_caps_new_empty (); slist0 = gdk_pixbuf_get_formats (); for (slist = slist0; slist; slist = g_slist_next (slist)) { GdkPixbufFormat *pixbuf_format; char **mimetypes; char **mimetype; pixbuf_format = slist->data; mimetypes = gdk_pixbuf_format_get_mime_types (pixbuf_format); for (mimetype = mimetypes; *mimetype; mimetype++) { gst_caps_append_structure (capslist, gst_structure_new_empty (*mimetype)); } g_strfreev (mimetypes); } g_slist_free (slist0); tmpl_caps = gst_static_caps_get (&gst_gdk_pixbuf_dec_sink_template.static_caps); return_caps = gst_caps_intersect (capslist, tmpl_caps); gst_caps_unref (tmpl_caps); gst_caps_unref (capslist); if (filter && return_caps) { GstCaps *temp; temp = gst_caps_intersect (return_caps, filter); gst_caps_unref (return_caps); return_caps = temp; } return return_caps; }
static void kms_face_detector_send_event (KmsFaceDetector * facedetector, GstVideoFrame * frame) { GstStructure *faces; GstStructure *timestamp; GstEvent *e; gint i; faces = gst_structure_new_empty ("faces"); timestamp = gst_structure_new ("time", "pts", G_TYPE_UINT64, GST_BUFFER_PTS (frame->buffer), "dts", G_TYPE_UINT64, GST_BUFFER_DTS (frame->buffer), NULL); gst_structure_set (faces, "timestamp", GST_TYPE_STRUCTURE, timestamp, NULL); gst_structure_free (timestamp); for (i = 0; i < (facedetector->priv->pFaceRectSeq ? facedetector->priv-> pFaceRectSeq->total : 0); i++) { CvRect *r; GstStructure *face; gchar *id = NULL; r = (CvRect *) cvGetSeqElem (facedetector->priv->pFaceRectSeq, i); face = gst_structure_new ("face", "x", G_TYPE_UINT, (guint) (r->x * facedetector->priv->resize_factor), "y", G_TYPE_UINT, (guint) (r->y * facedetector->priv->resize_factor), "width", G_TYPE_UINT, (guint) (r->width * facedetector->priv->resize_factor), "height", G_TYPE_UINT, (guint) (r->height * facedetector->priv->resize_factor), NULL); id = g_strdup_printf ("%d", i); gst_structure_set (faces, id, GST_TYPE_STRUCTURE, face, NULL); gst_structure_free (face); g_free (id); } /* post a faces detected event to src pad */ e = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, faces); gst_pad_push_event (facedetector->base.element.srcpad, e); }
static void dec_counter (GstPlayRegion *PlayRegion) { if (PlayRegion->prerolled) return; if (g_atomic_int_dec_and_test (&PlayRegion->counter)) { /* all probes blocked and no-more-pads signaled, post * message on the bus. */ PlayRegion->prerolled = TRUE; g_print ("fire application message\n"); gst_bus_post (PlayRegion->bus, gst_message_new_application ( GST_OBJECT_CAST (PlayRegion->pipeline), gst_structure_new_empty ("ExPrerolled"))); } }
GstStructure * get_roi_structure (const gchar * id) { int pointCount = 0; GstStructure *roiStructure, *configRoiSt; roiStructure = gst_structure_new_empty (id); for (pointCount = 0; pointCount < 4; pointCount++) { GstStructure *pointSt; gchar *name; name = g_strdup_printf ("point%d", pointCount); pointSt = gst_structure_new (name, "x", G_TYPE_INT, 10 + pointCount, "y", G_TYPE_INT, 10 + pointCount, NULL); gst_structure_set (roiStructure, name, GST_TYPE_STRUCTURE, pointSt, NULL); gst_structure_free (pointSt); g_free (name); } configRoiSt = gst_structure_new ("config", "id", G_TYPE_STRING, id, "occupancy_level_min", G_TYPE_INT, 10, "occupancy_level_med", G_TYPE_INT, 35, "occupancy_level_max", G_TYPE_INT, 65, "occupancy_num_frames_to_event", G_TYPE_INT, 5, "fluidity_level_min", G_TYPE_INT, 10, "fluidity_level_med", G_TYPE_INT, 35, "fluidity_level_max", G_TYPE_INT, 65, "fluidity_num_frames_to_event", G_TYPE_INT, 5, "send_optical_flow_event", G_TYPE_BOOLEAN, FALSE, "optical_flow_num_frames_to_event", G_TYPE_INT, 3, "optical_flow_num_frames_to_reset", G_TYPE_INT, 3, "optical_flow_angle_offset", G_TYPE_INT, 0, NULL); gst_structure_set (roiStructure, "config", GST_TYPE_STRUCTURE, configRoiSt, NULL); gst_structure_free (configRoiSt); return roiStructure; }
static GstStructure * create_rtxsenders (RtxSender * senders, guint senders_num) { GstStructure *recv_pt_map = gst_structure_new_empty ("application/x-rtp-pt-map"); for (gint i = 0; i < senders_num; ++i) { gchar *master_pt_str; gchar *master_caps_str; GstStructure *send_pt_map; senders[i].h = gst_harness_new ("rtprtxsend"); senders[i].master_ssrc = 1234567 + i; senders[i].rtx_ssrc = 7654321 + i; senders[i].master_pt = 80 + i; senders[i].rtx_pt = 20 + i; senders[i].seqnum = i * 1000; senders[i].expected_rtx_packets = 0; master_pt_str = g_strdup_printf ("%u", senders[i].master_pt); master_caps_str = g_strdup_printf ("application/x-rtp, " "media = (string)video, payload = (int)%u, " "ssrc = (uint)%u, clock-rate = (int)90000, " "encoding-name = (string)RAW", senders[i].master_pt, senders[i].master_ssrc); send_pt_map = gst_structure_new ("application/x-rtp-pt-map", master_pt_str, G_TYPE_UINT, senders[i].rtx_pt, NULL); gst_structure_set (recv_pt_map, master_pt_str, G_TYPE_UINT, senders[i].rtx_pt, NULL); g_object_set (senders[i].h->element, "payload-type-map", send_pt_map, NULL); gst_harness_set_src_caps_str (senders[i].h, master_caps_str); gst_structure_free (send_pt_map); g_free (master_pt_str); g_free (master_caps_str); } return recv_pt_map; }
CrowdDetectorFilterImpl::CrowdDetectorFilterImpl (const boost::property_tree::ptree &config, std::shared_ptr<MediaPipeline> mediaPipeline, const std::vector<std::shared_ptr<RegionOfInterest>> &rois) : FilterImpl ( config, std::dynamic_pointer_cast<MediaPipelineImpl> (mediaPipeline) ) { GstStructure *roisStructure; g_object_set (element, "filter-factory", "crowddetector", NULL); g_object_get (G_OBJECT (element), "filter", &crowdDetector, NULL); if (crowdDetector == NULL) { throw KurentoException (MEDIA_OBJECT_NOT_AVAILABLE, "Media Object not available"); } roisStructure = gst_structure_new_empty ("Rois"); for (auto roi : rois) { GstStructure *roiStructureAux = get_structure_from_roi (roi); gst_structure_set (roisStructure, roi->getId().c_str(), GST_TYPE_STRUCTURE, roiStructureAux, NULL); gst_structure_free (roiStructureAux); } g_object_set (G_OBJECT (crowdDetector), ROIS_PARAM, roisStructure, NULL); gst_structure_free (roisStructure); bus_handler_id = 0; // There is no need to reference crowddetector because its life cycle is the same as the filter life cycle g_object_unref (crowdDetector); }
static void kms_crowd_detector_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) { KmsCrowdDetector *crowddetector = KMS_CROWD_DETECTOR (object); GST_DEBUG_OBJECT (crowddetector, "get_property"); switch (property_id) { case PROP_SHOW_DEBUG_INFO: g_value_set_boolean (value, crowddetector->priv->show_debug_info); break; case PROP_ROIS: if (crowddetector->priv->rois == NULL) { crowddetector->priv->rois = gst_structure_new_empty ("rois"); } g_value_set_boxed (value, crowddetector->priv->rois); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static gboolean gst_video_scale_set_info (GstVideoFilter * filter, GstCaps * in, GstVideoInfo * in_info, GstCaps * out, GstVideoInfo * out_info) { GstVideoScale *videoscale = GST_VIDEO_SCALE (filter); gint from_dar_n, from_dar_d, to_dar_n, to_dar_d; if (!gst_util_fraction_multiply (in_info->width, in_info->height, in_info->par_n, in_info->par_d, &from_dar_n, &from_dar_d)) { from_dar_n = from_dar_d = -1; } if (!gst_util_fraction_multiply (out_info->width, out_info->height, out_info->par_n, out_info->par_d, &to_dar_n, &to_dar_d)) { to_dar_n = to_dar_d = -1; } videoscale->borders_w = videoscale->borders_h = 0; if (to_dar_n != from_dar_n || to_dar_d != from_dar_d) { if (videoscale->add_borders) { gint n, d, to_h, to_w; if (from_dar_n != -1 && from_dar_d != -1 && gst_util_fraction_multiply (from_dar_n, from_dar_d, out_info->par_d, out_info->par_n, &n, &d)) { to_h = gst_util_uint64_scale_int (out_info->width, d, n); if (to_h <= out_info->height) { videoscale->borders_h = out_info->height - to_h; videoscale->borders_w = 0; } else { to_w = gst_util_uint64_scale_int (out_info->height, n, d); g_assert (to_w <= out_info->width); videoscale->borders_h = 0; videoscale->borders_w = out_info->width - to_w; } } else { GST_WARNING_OBJECT (videoscale, "Can't calculate borders"); } } else { GST_WARNING_OBJECT (videoscale, "Can't keep DAR!"); } } if (in_info->width == out_info->width && in_info->height == out_info->height && videoscale->borders_w == 0 && videoscale->borders_h == 0) { gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (filter), TRUE); } else { GstStructure *options; GST_CAT_DEBUG_OBJECT (CAT_PERFORMANCE, filter, "setup videoscaling"); gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (filter), FALSE); options = gst_structure_new_empty ("videoscale"); switch (videoscale->method) { case GST_VIDEO_SCALE_NEAREST: gst_structure_set (options, GST_VIDEO_CONVERTER_OPT_RESAMPLER_METHOD, GST_TYPE_VIDEO_RESAMPLER_METHOD, GST_VIDEO_RESAMPLER_METHOD_NEAREST, NULL); break; case GST_VIDEO_SCALE_BILINEAR: gst_structure_set (options, GST_VIDEO_CONVERTER_OPT_RESAMPLER_METHOD, GST_TYPE_VIDEO_RESAMPLER_METHOD, GST_VIDEO_RESAMPLER_METHOD_LINEAR, GST_VIDEO_RESAMPLER_OPT_MAX_TAPS, G_TYPE_INT, 2, NULL); break; case GST_VIDEO_SCALE_4TAP: gst_structure_set (options, GST_VIDEO_CONVERTER_OPT_RESAMPLER_METHOD, GST_TYPE_VIDEO_RESAMPLER_METHOD, GST_VIDEO_RESAMPLER_METHOD_SINC, GST_VIDEO_RESAMPLER_OPT_MAX_TAPS, G_TYPE_INT, 4, NULL); break; case GST_VIDEO_SCALE_LANCZOS: gst_structure_set (options, GST_VIDEO_CONVERTER_OPT_RESAMPLER_METHOD, GST_TYPE_VIDEO_RESAMPLER_METHOD, GST_VIDEO_RESAMPLER_METHOD_LANCZOS, NULL); break; case GST_VIDEO_SCALE_BILINEAR2: gst_structure_set (options, GST_VIDEO_CONVERTER_OPT_RESAMPLER_METHOD, GST_TYPE_VIDEO_RESAMPLER_METHOD, GST_VIDEO_RESAMPLER_METHOD_LINEAR, NULL); break; case GST_VIDEO_SCALE_SINC: gst_structure_set (options, GST_VIDEO_CONVERTER_OPT_RESAMPLER_METHOD, GST_TYPE_VIDEO_RESAMPLER_METHOD, GST_VIDEO_RESAMPLER_METHOD_SINC, NULL); break; case GST_VIDEO_SCALE_HERMITE: gst_structure_set (options, GST_VIDEO_CONVERTER_OPT_RESAMPLER_METHOD, GST_TYPE_VIDEO_RESAMPLER_METHOD, GST_VIDEO_RESAMPLER_METHOD_CUBIC, GST_VIDEO_RESAMPLER_OPT_CUBIC_B, G_TYPE_DOUBLE, (gdouble) 0.0, GST_VIDEO_RESAMPLER_OPT_CUBIC_C, G_TYPE_DOUBLE, (gdouble) 0.0, NULL); break; case GST_VIDEO_SCALE_SPLINE: gst_structure_set (options, GST_VIDEO_CONVERTER_OPT_RESAMPLER_METHOD, GST_TYPE_VIDEO_RESAMPLER_METHOD, GST_VIDEO_RESAMPLER_METHOD_CUBIC, GST_VIDEO_RESAMPLER_OPT_CUBIC_B, G_TYPE_DOUBLE, (gdouble) 1.0, GST_VIDEO_RESAMPLER_OPT_CUBIC_C, G_TYPE_DOUBLE, (gdouble) 0.0, NULL); break; case GST_VIDEO_SCALE_CATROM: gst_structure_set (options, GST_VIDEO_CONVERTER_OPT_RESAMPLER_METHOD, GST_TYPE_VIDEO_RESAMPLER_METHOD, GST_VIDEO_RESAMPLER_METHOD_CUBIC, GST_VIDEO_RESAMPLER_OPT_CUBIC_B, G_TYPE_DOUBLE, (gdouble) 0.0, GST_VIDEO_RESAMPLER_OPT_CUBIC_C, G_TYPE_DOUBLE, (gdouble) 0.5, NULL); break; case GST_VIDEO_SCALE_MITCHELL: gst_structure_set (options, GST_VIDEO_CONVERTER_OPT_RESAMPLER_METHOD, GST_TYPE_VIDEO_RESAMPLER_METHOD, GST_VIDEO_RESAMPLER_METHOD_CUBIC, GST_VIDEO_RESAMPLER_OPT_CUBIC_B, G_TYPE_DOUBLE, (gdouble) 1.0 / 3.0, GST_VIDEO_RESAMPLER_OPT_CUBIC_C, G_TYPE_DOUBLE, (gdouble) 1.0 / 3.0, NULL); break; } gst_structure_set (options, GST_VIDEO_RESAMPLER_OPT_ENVELOPE, G_TYPE_DOUBLE, videoscale->envelope, GST_VIDEO_RESAMPLER_OPT_SHARPNESS, G_TYPE_DOUBLE, videoscale->sharpness, GST_VIDEO_RESAMPLER_OPT_SHARPEN, G_TYPE_DOUBLE, videoscale->sharpen, GST_VIDEO_CONVERTER_OPT_DEST_X, G_TYPE_INT, videoscale->borders_w / 2, GST_VIDEO_CONVERTER_OPT_DEST_Y, G_TYPE_INT, videoscale->borders_h / 2, GST_VIDEO_CONVERTER_OPT_DEST_WIDTH, G_TYPE_INT, out_info->width - videoscale->borders_w, GST_VIDEO_CONVERTER_OPT_DEST_HEIGHT, G_TYPE_INT, out_info->height - videoscale->borders_h, GST_VIDEO_CONVERTER_OPT_MATRIX_MODE, GST_TYPE_VIDEO_MATRIX_MODE, GST_VIDEO_MATRIX_MODE_NONE, GST_VIDEO_CONVERTER_OPT_DITHER_METHOD, GST_TYPE_VIDEO_DITHER_METHOD, GST_VIDEO_DITHER_NONE, GST_VIDEO_CONVERTER_OPT_CHROMA_MODE, GST_TYPE_VIDEO_CHROMA_MODE, GST_VIDEO_CHROMA_MODE_NONE, NULL); if (videoscale->gamma_decode) { gst_structure_set (options, GST_VIDEO_CONVERTER_OPT_GAMMA_MODE, GST_TYPE_VIDEO_GAMMA_MODE, GST_VIDEO_GAMMA_MODE_REMAP, NULL); } if (videoscale->convert) gst_video_converter_free (videoscale->convert); videoscale->convert = gst_video_converter_new (in_info, out_info, options); } GST_DEBUG_OBJECT (videoscale, "from=%dx%d (par=%d/%d dar=%d/%d), size %" G_GSIZE_FORMAT " -> to=%dx%d (par=%d/%d dar=%d/%d borders=%d:%d), " "size %" G_GSIZE_FORMAT, in_info->width, in_info->height, in_info->par_n, in_info->par_d, from_dar_n, from_dar_d, in_info->size, out_info->width, out_info->height, out_info->par_n, out_info->par_d, to_dar_n, to_dar_d, videoscale->borders_w, videoscale->borders_h, out_info->size); return TRUE; }
/* Probe on the output of a parser chain (the last * src pad) */ static GstPadProbeReturn parse_chain_output_probe (GstPad * pad, GstPadProbeInfo * info, DecodebinInputStream * input) { GstPadProbeReturn ret = GST_PAD_PROBE_OK; if (GST_IS_EVENT (GST_PAD_PROBE_INFO_DATA (info))) { GstEvent *ev = GST_PAD_PROBE_INFO_EVENT (info); GST_DEBUG_OBJECT (pad, "Got event %s", GST_EVENT_TYPE_NAME (ev)); switch (GST_EVENT_TYPE (ev)) { case GST_EVENT_STREAM_START: { GstStream *stream = NULL; guint group_id = G_MAXUINT32; gst_event_parse_group_id (ev, &group_id); GST_DEBUG_OBJECT (pad, "Got stream-start, group_id:%d, input %p", group_id, input->input); if (set_input_group_id (input->input, &group_id)) { ev = gst_event_make_writable (ev); gst_event_set_group_id (ev, group_id); GST_PAD_PROBE_INFO_DATA (info) = ev; } input->saw_eos = FALSE; gst_event_parse_stream (ev, &stream); /* FIXME : Would we ever end up with a stream already set on the input ?? */ if (stream) { if (input->active_stream != stream) { MultiQueueSlot *slot; if (input->active_stream) gst_object_unref (input->active_stream); input->active_stream = stream; /* We have the beginning of a stream, get a multiqueue slot and link to it */ g_mutex_lock (&input->dbin->selection_lock); slot = get_slot_for_input (input->dbin, input); link_input_to_slot (input, slot); g_mutex_unlock (&input->dbin->selection_lock); } else gst_object_unref (stream); } } break; case GST_EVENT_CAPS: { GstCaps *caps = NULL; gst_event_parse_caps (ev, &caps); GST_DEBUG_OBJECT (pad, "caps %" GST_PTR_FORMAT, caps); if (caps && input->active_stream) gst_stream_set_caps (input->active_stream, caps); } break; case GST_EVENT_EOS: input->saw_eos = TRUE; if (all_inputs_are_eos (input->dbin)) { GST_DEBUG_OBJECT (pad, "real input pad, marking as EOS"); check_all_streams_for_eos (input->dbin); } else { GstPad *peer = gst_pad_get_peer (input->srcpad); if (peer) { /* Send custom-eos event to multiqueue slot */ GstStructure *s; GstEvent *event; GST_DEBUG_OBJECT (pad, "Got EOS end of input stream, post custom-eos"); s = gst_structure_new_empty ("decodebin3-custom-eos"); event = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, s); gst_pad_send_event (peer, event); gst_object_unref (peer); } else { GST_FIXME_OBJECT (pad, "No peer, what should we do ?"); } } ret = GST_PAD_PROBE_DROP; break; case GST_EVENT_FLUSH_STOP: GST_DEBUG_OBJECT (pad, "Clear saw_eos flag"); input->saw_eos = FALSE; default: break; } } else if (GST_IS_QUERY (GST_PAD_PROBE_INFO_DATA (info))) { GstQuery *q = GST_PAD_PROBE_INFO_QUERY (info); GST_DEBUG_OBJECT (pad, "Seeing query %s", GST_QUERY_TYPE_NAME (q)); /* If we have a parser, we want to reply to the caps query */ /* FIXME: Set a flag when the input stream is created for * streams where we shouldn't reply to these queries */ if (GST_QUERY_TYPE (q) == GST_QUERY_CAPS && (info->type & GST_PAD_PROBE_TYPE_PULL)) { GstCaps *filter = NULL; GstCaps *allowed; gst_query_parse_caps (q, &filter); allowed = get_parser_caps_filter (input->dbin, filter); GST_DEBUG_OBJECT (pad, "Intercepting caps query, setting %" GST_PTR_FORMAT, allowed); gst_query_set_caps_result (q, allowed); gst_caps_unref (allowed); ret = GST_PAD_PROBE_HANDLED; } else if (GST_QUERY_TYPE (q) == GST_QUERY_ACCEPT_CAPS) { GstCaps *prop = NULL; gst_query_parse_accept_caps (q, &prop); /* Fast check against target caps */ if (gst_caps_can_intersect (prop, input->dbin->caps)) gst_query_set_accept_caps_result (q, TRUE); else { gboolean accepted = check_parser_caps_filter (input->dbin, prop); /* check against caps filter */ gst_query_set_accept_caps_result (q, accepted); GST_DEBUG_OBJECT (pad, "ACCEPT_CAPS query, returning %d", accepted); } ret = GST_PAD_PROBE_HANDLED; } } return ret; }
static gboolean gst_uri_downloader_set_uri (GstUriDownloader * downloader, const gchar * uri, const gchar * referer, gboolean compress, gboolean refresh, gboolean allow_cache) { GstPad *pad; GObjectClass *gobject_class; if (!gst_uri_is_valid (uri)) return FALSE; if (downloader->priv->urisrc) { gchar *old_protocol, *new_protocol; gchar *old_uri; old_uri = gst_uri_handler_get_uri (GST_URI_HANDLER (downloader->priv->urisrc)); old_protocol = gst_uri_get_protocol (old_uri); new_protocol = gst_uri_get_protocol (uri); if (!g_str_equal (old_protocol, new_protocol)) { gst_element_set_state (downloader->priv->urisrc, GST_STATE_NULL); gst_object_unref (downloader->priv->urisrc); downloader->priv->urisrc = NULL; GST_DEBUG_OBJECT (downloader, "Can't re-use old source element"); } else { GError *err = NULL; GST_DEBUG_OBJECT (downloader, "Re-using old source element"); if (!gst_uri_handler_set_uri (GST_URI_HANDLER (downloader->priv->urisrc), uri, &err)) { GST_DEBUG_OBJECT (downloader, "Failed to re-use old source element: %s", err->message); g_clear_error (&err); gst_element_set_state (downloader->priv->urisrc, GST_STATE_NULL); gst_object_unref (downloader->priv->urisrc); downloader->priv->urisrc = NULL; } } g_free (old_uri); g_free (old_protocol); g_free (new_protocol); } if (!downloader->priv->urisrc) { GST_DEBUG_OBJECT (downloader, "Creating source element for the URI:%s", uri); downloader->priv->urisrc = gst_element_make_from_uri (GST_URI_SRC, uri, NULL, NULL); if (!downloader->priv->urisrc) return FALSE; } gobject_class = G_OBJECT_GET_CLASS (downloader->priv->urisrc); if (g_object_class_find_property (gobject_class, "compress")) g_object_set (downloader->priv->urisrc, "compress", compress, NULL); if (g_object_class_find_property (gobject_class, "keep-alive")) g_object_set (downloader->priv->urisrc, "keep-alive", TRUE, NULL); if (g_object_class_find_property (gobject_class, "extra-headers")) { if (referer || refresh || !allow_cache) { GstStructure *extra_headers = gst_structure_new_empty ("headers"); if (referer) gst_structure_set (extra_headers, "Referer", G_TYPE_STRING, referer, NULL); if (!allow_cache) gst_structure_set (extra_headers, "Cache-Control", G_TYPE_STRING, "no-cache", NULL); else if (refresh) gst_structure_set (extra_headers, "Cache-Control", G_TYPE_STRING, "max-age=0", NULL); g_object_set (downloader->priv->urisrc, "extra-headers", extra_headers, NULL); gst_structure_free (extra_headers); } else { g_object_set (downloader->priv->urisrc, "extra-headers", NULL, NULL); } } /* add a sync handler for the bus messages to detect errors in the download */ gst_element_set_bus (GST_ELEMENT (downloader->priv->urisrc), downloader->priv->bus); gst_bus_set_sync_handler (downloader->priv->bus, gst_uri_downloader_bus_handler, downloader, NULL); pad = gst_element_get_static_pad (downloader->priv->urisrc, "src"); if (!pad) return FALSE; gst_pad_link (pad, downloader->priv->pad); gst_object_unref (pad); return TRUE; }
static GstCaps * gst_rtp_h264_pay_getcaps (GstRTPBasePayload * payload, GstPad * pad, GstCaps * filter) { GstCaps *template_caps; GstCaps *allowed_caps; GstCaps *caps, *icaps; gboolean append_unrestricted; guint i; allowed_caps = gst_pad_peer_query_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload), NULL); if (allowed_caps == NULL) return NULL; template_caps = gst_static_pad_template_get_caps (&gst_rtp_h264_pay_sink_template); if (gst_caps_is_any (allowed_caps)) { caps = gst_caps_ref (template_caps); goto done; } if (gst_caps_is_empty (allowed_caps)) { caps = gst_caps_ref (allowed_caps); goto done; } caps = gst_caps_new_empty (); append_unrestricted = FALSE; for (i = 0; i < gst_caps_get_size (allowed_caps); i++) { GstStructure *s = gst_caps_get_structure (allowed_caps, i); GstStructure *new_s = gst_structure_new_empty ("video/x-h264"); const gchar *profile_level_id; profile_level_id = gst_structure_get_string (s, "profile-level-id"); if (profile_level_id && strlen (profile_level_id) == 6) { const gchar *profile; const gchar *level; long int spsint; guint8 sps[3]; spsint = strtol (profile_level_id, NULL, 16); sps[0] = spsint >> 16; sps[1] = spsint >> 8; sps[2] = spsint; profile = gst_codec_utils_h264_get_profile (sps, 3); level = gst_codec_utils_h264_get_level (sps, 3); if (profile && level) { GST_LOG_OBJECT (payload, "In caps, have profile %s and level %s", profile, level); if (!strcmp (profile, "constrained-baseline")) gst_structure_set (new_s, "profile", G_TYPE_STRING, profile, NULL); else { GValue val = { 0, }; GValue profiles = { 0, }; g_value_init (&profiles, GST_TYPE_LIST); g_value_init (&val, G_TYPE_STRING); g_value_set_static_string (&val, profile); gst_value_list_append_value (&profiles, &val); g_value_set_static_string (&val, "constrained-baseline"); gst_value_list_append_value (&profiles, &val); gst_structure_take_value (new_s, "profile", &profiles); } if (!strcmp (level, "1")) gst_structure_set (new_s, "level", G_TYPE_STRING, level, NULL); else { GValue levels = { 0, }; GValue val = { 0, }; int j; g_value_init (&levels, GST_TYPE_LIST); g_value_init (&val, G_TYPE_STRING); for (j = 0; j < G_N_ELEMENTS (all_levels); j++) { g_value_set_static_string (&val, all_levels[j]); gst_value_list_prepend_value (&levels, &val); if (!strcmp (level, all_levels[j])) break; } gst_structure_take_value (new_s, "level", &levels); } } else { /* Invalid profile-level-id means baseline */ gst_structure_set (new_s, "profile", G_TYPE_STRING, "constrained-baseline", NULL); } } else { /* No profile-level-id means baseline or unrestricted */ gst_structure_set (new_s, "profile", G_TYPE_STRING, "constrained-baseline", NULL); append_unrestricted = TRUE; } caps = gst_caps_merge_structure (caps, new_s); }