/** * gst_buffer_pool_config_add_option: * @config: a #GstBufferPool configuration * @option: an option to add * * Enabled the option in @config. This will instruct the @bufferpool to enable * the specified option on the buffers that it allocates. * * The supported options by @pool can be retrieved with gst_buffer_pool_get_options(). */ void gst_buffer_pool_config_add_option (GstStructure * config, const gchar * option) { const GValue *value; GValue option_value = { 0, }; guint i, len; g_return_if_fail (config != NULL); value = gst_structure_id_get_value (config, GST_QUARK (OPTIONS)); if (value) { len = gst_value_array_get_size (value); for (i = 0; i < len; ++i) { const GValue *nth_val = gst_value_array_get_value (value, i); if (g_str_equal (option, g_value_get_string (nth_val))) return; } } else { GValue new_array_val = { 0, }; g_value_init (&new_array_val, GST_TYPE_ARRAY); gst_structure_id_take_value (config, GST_QUARK (OPTIONS), &new_array_val); value = gst_structure_id_get_value (config, GST_QUARK (OPTIONS)); } g_value_init (&option_value, G_TYPE_STRING); g_value_set_string (&option_value, option); gst_value_array_append_value ((GValue *) value, &option_value); g_value_unset (&option_value); }
/** * 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; }