static void on_rate_changed (GstElement * element, gint rate, gpointer user_data) { GValueArray *va; GValue v = { 0, }; gdouble x; if (rate / 2.0 > CUTOFF) x = exp (-2.0 * G_PI * (CUTOFF / rate)); else x = 0.0; va = g_value_array_new (1); g_value_init (&v, G_TYPE_DOUBLE); g_value_set_double (&v, 1.0 - x); g_value_array_append (va, &v); g_value_reset (&v); g_object_set (G_OBJECT (element), "a", va, NULL); g_value_array_free (va); va = g_value_array_new (1); g_value_set_double (&v, x); g_value_array_append (va, &v); g_value_reset (&v); g_object_set (G_OBJECT (element), "b", va, NULL); g_value_array_free (va); }
gboolean my_object_send_car (MyObject *obj, GValueArray *invals, GValueArray **outvals, GError **error) { if (invals->n_values != 3 || G_VALUE_TYPE (g_value_array_get_nth (invals, 0)) != G_TYPE_STRING || G_VALUE_TYPE (g_value_array_get_nth (invals, 1)) != G_TYPE_UINT || G_VALUE_TYPE (g_value_array_get_nth (invals, 2)) != G_TYPE_VALUE) { g_set_error (error, MY_OBJECT_ERROR, MY_OBJECT_ERROR_FOO, "invalid incoming values"); return FALSE; } *outvals = g_value_array_new (2); g_value_array_append (*outvals, NULL); g_value_init (g_value_array_get_nth (*outvals, (*outvals)->n_values - 1), G_TYPE_UINT); g_value_set_uint (g_value_array_get_nth (*outvals, (*outvals)->n_values - 1), g_value_get_uint (g_value_array_get_nth (invals, 1)) + 1); g_value_array_append (*outvals, NULL); g_value_init (g_value_array_get_nth (*outvals, (*outvals)->n_values - 1), DBUS_TYPE_G_OBJECT_PATH); g_value_set_boxed (g_value_array_get_nth (*outvals, (*outvals)->n_values - 1), g_strdup ("/org/freedesktop/DBus/GLib/Tests/MyTestObject2")); 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); }
/** * sw_item_stream_remove_item * @item_stream: A #SwItemStream * @item: A #SwItem * * Remove a single item to the #SwItemStream. This will cause a signal to be * emitted across the bus. */ void sw_item_stream_remove_item (SwItemStream *item_stream, SwItem *item) { GValueArray *value_array; GPtrArray *ptr_array; ptr_array = g_ptr_array_new (); value_array = g_value_array_new (2); value_array = g_value_array_append (value_array, NULL); g_value_init (g_value_array_get_nth (value_array, 0), G_TYPE_STRING); g_value_set_string (g_value_array_get_nth (value_array, 0), sw_service_get_name (sw_item_get_service (item))); value_array = g_value_array_append (value_array, NULL); g_value_init (g_value_array_get_nth (value_array, 1), G_TYPE_STRING); g_value_set_string (g_value_array_get_nth (value_array, 1), sw_item_get (item, "id")); g_ptr_array_add (ptr_array, value_array); sw_item_view_iface_emit_items_removed (item_stream, ptr_array); g_ptr_array_free (ptr_array, TRUE); }
static guint fill_binnings(UcaPcoCameraPrivate *priv) { uint16_t *horizontal = NULL; uint16_t *vertical = NULL; guint num_horizontal, num_vertical; guint err = pco_get_possible_binnings(priv->pco, &horizontal, &num_horizontal, &vertical, &num_vertical); GValue val = {0}; g_value_init(&val, G_TYPE_UINT); if (err == PCO_NOERROR) { priv->horizontal_binnings = g_value_array_new(num_horizontal); priv->vertical_binnings = g_value_array_new(num_vertical); for (guint i = 0; i < num_horizontal; i++) { g_value_set_uint(&val, horizontal[i]); g_value_array_append(priv->horizontal_binnings, &val); } for (guint i = 0; i < num_vertical; i++) { g_value_set_uint(&val, vertical[i]); g_value_array_append(priv->vertical_binnings, &val); } } free(horizontal); free(vertical); return err; }
static void alias_updated_cb (ExampleContactListManager *manager, TpHandle contact, ExampleContactListConnection *self) { GPtrArray *aliases; GValueArray *pair; pair = g_value_array_new (2); g_value_array_append (pair, NULL); g_value_array_append (pair, NULL); g_value_init (pair->values + 0, G_TYPE_UINT); g_value_init (pair->values + 1, G_TYPE_STRING); g_value_set_uint (pair->values + 0, contact); g_value_set_string (pair->values + 1, example_contact_list_manager_get_alias (manager, contact)); aliases = g_ptr_array_sized_new (1); g_ptr_array_add (aliases, pair); tp_svc_connection_interface_aliasing_emit_aliases_changed (self, aliases); g_ptr_array_free (aliases, TRUE); g_value_array_free (pair); }
/** * mojito_item_view_remove_items * @item_view: A #MojitoItemView * @items: A list of #MojitoItem objects * * Remove the items supplied in the list from the #MojitoItemView. In many * cases what you actually want is mojito_item_view_remove_from_set() or * mojito_item_view_set_from_set(). This will cause signal emissions over the * bus. * * This is used in the implementation of mojito_item_view_remove_from_set() */ void mojito_item_view_remove_items (MojitoItemView *item_view, GList *items) { GValueArray *value_array; GPtrArray *ptr_array; GList *l; MojitoItem *item; ptr_array = g_ptr_array_new (); for (l = items; l; l = l->next) { item = MOJITO_ITEM (l->data); value_array = g_value_array_new (2); value_array = g_value_array_append (value_array, NULL); g_value_init (g_value_array_get_nth (value_array, 0), G_TYPE_STRING); g_value_set_string (g_value_array_get_nth (value_array, 0), mojito_service_get_name (mojito_item_get_service (item))); value_array = g_value_array_append (value_array, NULL); g_value_init (g_value_array_get_nth (value_array, 1), G_TYPE_STRING); g_value_set_string (g_value_array_get_nth (value_array, 1), mojito_item_get (item, "id")); g_ptr_array_add (ptr_array, value_array); } mojito_item_view_iface_emit_items_removed (item_view, ptr_array); }
/* * Construct a GValueArray from a SwItem. We use this to construct the * data types that the wonderful dbus-glib needs to emit the signal */ GValueArray * _sw_item_to_value_array (SwItem *item) { GValueArray *value_array; time_t time; time = sw_time_t_from_string (sw_item_get (item, "date")); value_array = g_value_array_new (4); value_array = g_value_array_append (value_array, NULL); g_value_init (g_value_array_get_nth (value_array, 0), G_TYPE_STRING); g_value_set_string (g_value_array_get_nth (value_array, 0), sw_service_get_name (sw_item_get_service (item))); value_array = g_value_array_append (value_array, NULL); g_value_init (g_value_array_get_nth (value_array, 1), G_TYPE_STRING); g_value_set_string (g_value_array_get_nth (value_array, 1), sw_item_get (item, "id")); value_array = g_value_array_append (value_array, NULL); g_value_init (g_value_array_get_nth (value_array, 2), G_TYPE_INT64); g_value_set_int64 (g_value_array_get_nth (value_array, 2), time); value_array = g_value_array_append (value_array, NULL); g_value_init (g_value_array_get_nth (value_array, 3), dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_STRING)); g_value_set_boxed (g_value_array_get_nth (value_array, 3), sw_item_peek_hash (item)); return value_array; }
static void theora_parse_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstTheoraParse *parse = GST_THEORA_PARSE (object); switch (prop_id) { case PROP_SYNCHRONIZATION_POINTS: { GValueArray *array = NULL; guint i; array = g_value_array_new (parse->npairs * 2); for (i = 0; i < parse->npairs; i++) { GValue v = { 0, }; g_value_init (&v, G_TYPE_UINT64); g_value_set_uint64 (&v, parse->times[i * 2]); g_value_array_append (array, &v); g_value_set_uint64 (&v, parse->times[i * 2 + 1]); g_value_array_append (array, &v); g_value_unset (&v); } g_value_take_boxed (value, array); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/** * sw_item_stream_remove_items * @item_stream: A #SwItemStream * @items: A list of #SwItem objects * * Remove the items supplied in the list from the #SwItemStream. This will cause * signal emissions over the bus. * */ void sw_item_stream_remove_items (SwItemStream *item_stream, GList *items) { GValueArray *value_array; GPtrArray *ptr_array; GList *l; SwItem *item; ptr_array = g_ptr_array_new_with_free_func ((GDestroyNotify)g_value_array_free); for (l = items; l; l = l->next) { item = SW_ITEM (l->data); value_array = g_value_array_new (2); value_array = g_value_array_append (value_array, NULL); g_value_init (g_value_array_get_nth (value_array, 0), G_TYPE_STRING); g_value_set_string (g_value_array_get_nth (value_array, 0), sw_service_get_name (sw_item_get_service (item))); value_array = g_value_array_append (value_array, NULL); g_value_init (g_value_array_get_nth (value_array, 1), G_TYPE_STRING); g_value_set_string (g_value_array_get_nth (value_array, 1), sw_item_get (item, "id")); g_ptr_array_add (ptr_array, value_array); } sw_item_view_iface_emit_items_removed (item_stream, ptr_array); g_ptr_array_free (ptr_array, TRUE); }
void conn_location_properties_getter (GObject *object, GQuark interface, GQuark name, GValue *value, gpointer getter_data) { GabbleConnection *conn = GABBLE_CONNECTION (object); if (!tp_strdiff (g_quark_to_string (name), "LocationAccessControlTypes")) { guint access_control_type = TP_RICH_PRESENCE_ACCESS_CONTROL_TYPE_PUBLISH_LIST; GArray *access_control = g_array_sized_new (FALSE, FALSE, sizeof (guint), 1); g_array_append_val (access_control, access_control_type); g_value_take_boxed (value, access_control); } else if (!tp_strdiff (g_quark_to_string (name), "LocationAccessControl")) { GValueArray *access_control = g_value_array_new (2); GValue type = {0,}; GValue variant = {0,}; GValue *allocated_value; /* G_TYPE_UINT is the D-Bus type of TpRichPresenceAccessControlType */ g_value_init (&type, G_TYPE_UINT); g_value_set_uint (&type, TP_RICH_PRESENCE_ACCESS_CONTROL_TYPE_PUBLISH_LIST); g_value_array_append (access_control, &type); g_value_unset (&type); g_value_init (&variant, G_TYPE_VALUE); /* For Publish_List, the variant isn't used, so we set a dummy value, * (guint) 0 */ allocated_value = tp_g_value_slice_new (G_TYPE_UINT); g_value_set_uint (allocated_value, 0); g_value_set_boxed (&variant, allocated_value); g_value_array_append (access_control, &variant); g_value_unset (&variant); tp_g_value_slice_free (allocated_value); g_value_take_boxed (value, access_control); } else if (name == g_quark_from_static_string ("SupportedLocationFeatures")) { TpLocationFeatures flags = 0; if (conn->features & GABBLE_CONNECTION_FEATURES_PEP) flags |= TP_LOCATION_FEATURE_CAN_SET; g_value_set_uint (value, flags); } else { g_assert_not_reached (); } }
static void gnome_print_filter_position_set_property (GObject *object, guint n, const GValue *v, GParamSpec *pspec) { GnomePrintFilterPosition *f = (GnomePrintFilterPosition *) object; switch (n) { case PROP_X: { gdouble d = g_value_get_double (v); GValueArray *va = g_value_array_new (6); GValue vd = {0,}; guint i; gdouble a[6]; f->x = d; art_affine_translate (a, f->x, f->y); g_value_init (&vd, G_TYPE_DOUBLE); for (i = 0; i < 6; i++) { g_value_set_double (&vd, a[i]); g_value_array_append (va, &vd); } g_value_unset (&vd); g_object_set (object, "transform", va, NULL); g_value_array_free (va); gnome_print_filter_changed (GNOME_PRINT_FILTER (f)); } break; case PROP_Y: { gdouble d = g_value_get_double (v); GValueArray *va = g_value_array_new (6); GValue vd = {0,}; guint i; gdouble a[6]; f->y = d; art_affine_translate (a, f->x, f->y); g_value_init (&vd, G_TYPE_DOUBLE); for (i = 0; i < 6; i++) { g_value_set_double (&vd, a[i]); g_value_array_append (va, &vd); } g_value_unset (&vd); g_object_set (object, "transform", va, NULL); g_value_array_free (va); gnome_print_filter_changed (GNOME_PRINT_FILTER (f)); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, n, pspec); } }
void empathy_tp_chat_set_property (EmpathyTpChat *chat, const gchar *name, const GValue *value) { EmpathyTpChatPriv *priv = GET_PRIV (chat); TpChatProperty *property; guint i; for (i = 0; i < priv->properties->len; i++) { property = g_ptr_array_index (priv->properties, i); if (!tp_strdiff (property->name, name)) { GPtrArray *properties; GValueArray *prop; GValue id = {0, }; GValue dest_value = {0, }; if (!(property->flags & TP_PROPERTY_FLAG_WRITE)) { break; } g_value_init (&id, G_TYPE_UINT); g_value_init (&dest_value, G_TYPE_VALUE); g_value_set_uint (&id, property->id); g_value_set_boxed (&dest_value, value); prop = g_value_array_new (2); g_value_array_append (prop, &id); g_value_array_append (prop, &dest_value); properties = g_ptr_array_sized_new (1); g_ptr_array_add (properties, prop); DEBUG ("Set property %s", name); tp_cli_properties_interface_call_set_properties (priv->channel, -1, properties, (tp_cli_properties_interface_callback_for_set_properties) tp_chat_async_cb, "Seting property", NULL, G_OBJECT (chat)); g_ptr_array_free (properties, TRUE); g_value_array_free (prop); break; } } }
END_TEST START_TEST(test_array) { MidgardQueryBuilder *builder = midgard_query_builder_new(mgd, "midgard_style"); fail_if(builder == NULL, NULL); GValue *value; GValueArray *array = g_value_array_new(2); value = g_new0(GValue, 1); g_value_init(value, G_TYPE_UINT); g_value_set_uint(value, 1); g_value_array_append(array, value); g_value_unset(value); g_free(value); value = g_new0(GValue, 1); g_value_init(value, G_TYPE_UINT); g_value_set_uint(value, 2); g_value_array_append(array, value); g_value_unset(value); g_free(value); value = g_new0(GValue, 1); g_value_init(value, G_TYPE_VALUE_ARRAY); g_value_set_boxed(value, array); midgard_query_builder_add_constraint(builder, "id", "IN", value); g_value_unset(value); g_free(value); g_value_array_free(array); guint n_objects; GObject **objects = midgard_query_builder_execute(builder, &n_objects); fail_if(objects == NULL, NULL); if (objects != NULL) { guint i; for (i = 0; i < n_objects; i++) { fail_if(objects[i] == NULL, NULL); g_object_unref(objects[i]); } } g_free(objects); midgard_query_builder_free(builder); }
/* Retrieve a GValueArray property from the preferences ini file. If an error occurs (usually because the preferences file does not exist, or the key value is not present, then NULL is returned */ static GValueArray* mame_gui_prefs_get_stringlist_property_from_key_file (MameGuiPrefs *pr, gchar *category, gchar *property) { GError *error = NULL; gchar **str_array; GValueArray *va; gsize paths; /* FIXME Define max number of rom/sample dirs */ guint i; va = g_value_array_new (4); /* FIXME TODO - define max number */ GMAMEUI_DEBUG ("Retrieving string array for category %s, property %s", category, property); str_array = g_key_file_get_string_list (pr->priv->prefs_ini_file, category, property, &paths, &error); for (i = 0; i < paths; i++) { GValue val = { 0, }; g_value_init (&val, G_TYPE_STRING); if ((str_array) && (str_array[i] != NULL)) g_value_set_string (&val, str_array[i]); /* If not available, default to NULL */ GMAMEUI_DEBUG (" Value for %s at %d is %s", property, i, g_value_get_string (&val)); va = g_value_array_append (va, &val); } if (error) { GMAMEUI_DEBUG (" Error retrieving %s: %s", property, error->message); g_error_free (error); error = NULL; } return va; }
/** * atk_relation_new: * @targets: an array of pointers to #AtkObjects * @n_targets: number of #AtkObjects pointed to by @targets * @relationship: an #AtkRelationType with which to create the new * #AtkRelation * * Create a new relation for the specified key and the specified list * of targets. See also atk_object_add_relationship(). * * Returns: a pointer to a new #AtkRelation **/ AtkRelation* atk_relation_new (AtkObject **targets, gint n_targets, AtkRelationType relationship) { AtkRelation *relation; int i; GValueArray *array; GValue *value; g_return_val_if_fail (targets != NULL, NULL); array = g_value_array_new (n_targets); for (i = 0; i < n_targets; i++) { value = g_new0 (GValue, 1); g_value_init (value, ATK_TYPE_OBJECT); g_value_set_object (value, targets[i]); array = g_value_array_append (array, value); g_value_unset (value); g_free (value); } relation = g_object_new (ATK_TYPE_RELATION, "relation_type", relationship, "target", array, NULL); g_value_array_free (array); return relation; }
/** * gst_factory_list_get_elements: * @type: a #GstFactoryListType * * Get a sorted list of factories of @type. * * Returns: a #GValueArray of #GstElementFactory elements. Use * g_value_array_free() after usage. */ GValueArray * gst_factory_list_get_elements (GstFactoryListType type) { GValueArray *result; GList *walk, *list; FilterData data; result = g_value_array_new (0); /* prepare type */ data.type = type; /* get the feature list using the filter */ list = gst_default_registry_feature_filter ((GstPluginFeatureFilter) element_filter, FALSE, &data); /* convert to an array */ for (walk = list; walk; walk = g_list_next (walk)) { GstElementFactory *factory = GST_ELEMENT_FACTORY (walk->data); GValue val = { 0, }; g_value_init (&val, G_TYPE_OBJECT); g_value_set_object (&val, factory); g_value_array_append (result, &val); g_value_unset (&val); } gst_plugin_feature_list_free (list); /* sort on rank and name */ g_value_array_sort (result, (GCompareFunc) compare_ranks); return result; }
GValueArray * gimp_dash_pattern_to_value_array (GArray *pattern) { if (pattern == NULL || pattern->len == 0) { return NULL; } else { GValueArray *value_array = g_value_array_new (pattern->len); GValue item = { 0, }; gint i; g_value_init (&item, G_TYPE_DOUBLE); for (i = 0; i < pattern->len; i++) { g_value_set_double (&item, g_array_index (pattern, gdouble, i)); g_value_array_append (value_array, &item); } g_value_unset (&item); return value_array; } }
static void tableTesData(GtkWidget* widget,gpointer data){ // databaseRubahFileMusic(); // return; gboolean status= FALSE; dataToSend_* dataTo = (dataToSend_*)data ; char* data_ = dataTo->file; gint id = dataTo->id; GValueArray* varr = g_value_array_new (-1); GValue a = {0}; g_assert (!G_VALUE_HOLDS_STRING (&a)); g_value_init (&a, G_TYPE_INT); g_value_set_int (&a, id); // g_print("%i\n", g_value_get_int (&a) ); varr = g_value_array_append(varr,&a); GValueArray* hasil = databaseGetDatasFromDb("select alarm from isi where id = ?", varr,&status); GValue *tmp = g_value_array_get_nth (hasil ,0 ); soundPlay( g_value_get_string(tmp) , 1); //clean g_value_array_free (varr); g_value_array_free (hasil); }
static void set_value_from_palette (GValue *ret_value, const GdkColor *colors, guint n_colors) { GValueArray *array; guint i, max_n_colors; max_n_colors = MAX (n_colors, TERMINAL_PALETTE_SIZE); array = g_value_array_new (max_n_colors); for (i = 0; i < max_n_colors; ++i) g_value_array_append (array, NULL); for (i = 0; i < n_colors; ++i) { GValue *value = g_value_array_get_nth (array, i); g_value_init (value, GDK_TYPE_COLOR); g_value_set_boxed (value, &colors[i]); } /* If we haven't enough colours yet, fill up with the default palette */ for (i = n_colors; i < TERMINAL_PALETTE_SIZE; ++i) { GValue *value = g_value_array_get_nth (array, i); g_value_init (value, GDK_TYPE_COLOR); g_value_set_boxed (value, &DEFAULT_PALETTE[i]); } g_value_take_boxed (ret_value, array); }
static GValueArray * jingle_create_relay_info(const gchar *ip, guint port, const gchar *username, const gchar *password, const gchar *relay_type, GValueArray *relay_info) { GValue value; GstStructure *turn_setup = gst_structure_new("relay-info", "ip", G_TYPE_STRING, ip, "port", G_TYPE_UINT, port, "username", G_TYPE_STRING, username, "password", G_TYPE_STRING, password, "relay-type", G_TYPE_STRING, relay_type, NULL); purple_debug_info("jabber", "created gst_structure %p\n", turn_setup); if (turn_setup) { memset(&value, 0, sizeof(GValue)); g_value_init(&value, GST_TYPE_STRUCTURE); gst_value_set_structure(&value, turn_setup); G_GNUC_BEGIN_IGNORE_DEPRECATIONS relay_info = g_value_array_append(relay_info, &value); G_GNUC_END_IGNORE_DEPRECATIONS gst_structure_free(turn_setup); } return relay_info; }
static GValueArray * gst_ks_video_src_get_device_name_values (GstKsVideoSrc * self) { GList *devices, *cur; GValueArray *array = g_value_array_new (0); devices = ks_enumerate_devices (&KSCATEGORY_VIDEO); if (devices == NULL) return array; devices = ks_video_device_list_sort_cameras_first (devices); for (cur = devices; cur != NULL; cur = cur->next) { GValue value = { 0, }; KsDeviceEntry *entry = cur->data; g_value_init (&value, G_TYPE_STRING); g_value_set_string (&value, entry->name); g_value_array_append (array, &value); g_value_unset (&value); ks_device_entry_free (entry); } g_list_free (devices); return array; }
GValueArray * mame_exec_list_get_list_as_value_array (MameExecList *list) { GList *node; GValueArray *va_paths; GValue val = { 0, }; va_paths = g_value_array_new (0); g_value_init (&val, G_TYPE_STRING); for (node = g_list_first (list->priv->list); node != NULL; node = g_list_next (node)) { MameExec *exec; gchar *path; exec = (MameExec *) node->data; g_object_get (exec, "exec-path", &path, NULL); g_value_set_string (&val, path); va_paths = g_value_array_append (va_paths, &val); /* GMAMEUI_DEBUG ("Adding %s to list of executables", path); */ g_free (path); } return va_paths; }
static gboolean char_class_string_extract(const gunichar *s, gsize length, struct char_class_data *data, GValueArray *array) { gunichar *ret = NULL; gsize len; gsize i; GValue value; len = unichar_snlen(s, length); ret = g_malloc0((len + 1) * sizeof(gunichar)); unichar_sncpy(ret, s, len); for (i = 0; i < len; i++) { ret[i] &= ~(VTE_ISO2022_ENCODED_WIDTH_MASK); } _vte_debug_print(VTE_DEBUG_PARSE, "Extracting string `%ls'.\n", (wchar_t*) ret); memset(&value, 0, sizeof(value)); g_value_init(&value, G_TYPE_POINTER); g_value_set_pointer(&value, ret); g_value_array_append(array, &value); g_value_unset(&value); return TRUE; }
static void append_int_value(GValueArray * ar, gint tmp) { GValue value; memset(&value, 0, sizeof(value)); g_value_init(&value, G_TYPE_INT); g_value_set_int(&value, tmp); g_value_array_append(ar, &value); }
static void on_rate_changed (GstElement * element, gint rate, gpointer user_data) { GValueArray *va; GValue v = { 0, }; GstFFTF64 *fft; GstFFTF64Complex frequency_response[17]; gdouble tmp[32]; gdouble filter_kernel[32]; guint i; /* Create the frequency response: zero outside * a small frequency band */ for (i = 0; i < 17; i++) { if (i < 5 || i > 11) frequency_response[i].r = 0.0; else frequency_response[i].r = 1.0; frequency_response[i].i = 0.0; } /* Calculate the inverse FT of the frequency response */ fft = gst_fft_f64_new (32, TRUE); gst_fft_f64_inverse_fft (fft, frequency_response, tmp); gst_fft_f64_free (fft); /* Shift the inverse FT of the frequency response by 16, * i.e. the half of the kernel length to get the * impulse response. See http://www.dspguide.com/ch17/1.htm * for more information. */ for (i = 0; i < 32; i++) filter_kernel[i] = tmp[(i + 16) % 32]; /* Apply the hamming window to the impulse response to get * a better result than given from the rectangular window */ for (i = 0; i < 32; i++) filter_kernel[i] *= (0.54 - 0.46 * cos (2 * G_PI * i / 32)); va = g_value_array_new (1); g_value_init (&v, G_TYPE_DOUBLE); for (i = 0; i < 32; i++) { g_value_set_double (&v, filter_kernel[i]); g_value_array_append (va, &v); g_value_reset (&v); } g_object_set (G_OBJECT (element), "kernel", va, NULL); /* Latency is 1/2 of the kernel length for this method of * calculating a filter kernel from the frequency response */ g_object_set (G_OBJECT (element), "latency", (gint64) (32 / 2), NULL); g_value_array_free (va); }
/** * gst_factory_list_filter: * @array: a #GValueArray to filter * @caps: a #GstCaps * * Filter out all the elementfactories in @array that can handle @caps as * input. * * Returns: a #GValueArray of #GstElementFactory elements. Use * g_value_array_free() after usage. */ GValueArray * gst_factory_list_filter (GValueArray * array, const GstCaps * caps) { GValueArray *result; gint i; result = g_value_array_new (0); GST_DEBUG ("finding factories"); /* loop over all the factories */ for (i = 0; i < array->n_values; i++) { GValue *value; GstElementFactory *factory; const GList *templates; GList *walk; value = g_value_array_get_nth (array, i); factory = g_value_get_object (value); /* get the templates from the element factory */ templates = gst_element_factory_get_static_pad_templates (factory); for (walk = (GList *) templates; walk; walk = g_list_next (walk)) { GstStaticPadTemplate *templ = walk->data; /* we only care about the sink templates */ if (templ->direction == GST_PAD_SINK) { GstCaps *intersect; GstCaps *tmpl_caps; /* try to intersect the caps with the caps of the template */ tmpl_caps = gst_static_caps_get (&templ->static_caps); /* FIXME, intersect is not the right method, we ideally want to check * for a subset here */ intersect = gst_caps_intersect (caps, tmpl_caps); gst_caps_unref (tmpl_caps); /* check if the intersection is empty */ if (!gst_caps_is_empty (intersect)) { /* non empty intersection, we can use this element */ GValue resval = { 0, }; g_value_init (&resval, G_TYPE_OBJECT); g_value_set_object (&resval, factory); g_value_array_append (result, &resval); g_value_unset (&resval); gst_caps_unref (intersect); break; } gst_caps_unref (intersect); } } } return result; }
static void _vte_table_extract_numbers(GValueArray **array, struct _vte_table_arginfo *arginfo) { GValue value = {0,}; GValue subvalue = {0,}; GValueArray *subarray = NULL; gssize i; if (G_UNLIKELY (*array == NULL)) { *array = g_value_array_new(1); } g_value_init(&value, G_TYPE_LONG); g_value_init(&subvalue, G_TYPE_VALUE_ARRAY); i = 0; do { long total = 0; for (; i < arginfo->length && arginfo->start[i] != ';' && arginfo->start[i] != ':'; i++) { gint v = g_unichar_digit_value (arginfo->start[i]); total *= 10; total += v == -1 ? 0 : v; } g_value_set_long(&value, CLAMP (total, 0, G_MAXUSHORT)); if (i < arginfo->length && arginfo->start[i] == ':') { if (subarray == NULL) { subarray = g_value_array_new(2); } g_value_array_append(subarray, &value); } else { if (subarray == NULL) { g_value_array_append(*array, &value); } else { g_value_array_append(subarray, &value); g_value_set_boxed(&subvalue, subarray); g_value_array_append(*array, &subvalue); subarray = NULL; } } } while (i++ < arginfo->length); g_value_unset(&value); }
/* char* databaseGetDataFromDb(char* sql , GValueArray *where){ char *tail, *hasil; int rc = sqlite3_prepare(sqlite->db, sql, strlen(sql), &sqlite->stmt, &tail); if(rc==SQLITE_OK){ int ema; for(ema=0;ema<1;ema++){ GValue* value = g_value_array_get_nth (where,ema); if(G_VALUE_TYPE(value) == G_TYPE_INT){ sqlite3_bind_int(sqlite->stmt , ema+1 , g_value_get_int(value) ); } else if( G_VALUE_TYPE(value) == G_TYPE_STRING ){ char * tmp = g_value_get_string(value); sqlite3_bind_text(sqlite->stmt , ema+1 , tmp , strlen(tmp), SQLITE_TRANSIENT ); } } // gint ncols = sqlite3_column_count(sqlite->stmt); sqlite3_step(sqlite->stmt); hasil = g_strdup_printf ("%s", sqlite3_column_text(sqlite->stmt, 0) ) ; } else{ fprintf(stderr, "sqlite3_prepare() : Error: %s\n", tail); } sqlite3_finalize(sqlite->stmt); return hasil; } */ GValueArray *databaseGetDatasFromDb(char* sql , GValueArray *where , gboolean *status ){ status = FALSE; GValueArray* hasil = g_value_array_new (-1); char *tail; int rc = sqlite3_prepare(sqlite->db, sql, strlen(sql), &sqlite->stmt, &tail); if(rc==SQLITE_OK){ status = TRUE; int ema; if(where != NULL){ for(ema=0;ema<where->n_values;ema++){ GValue* value = g_value_array_get_nth (where,ema); if(G_VALUE_TYPE(value) == G_TYPE_INT){ sqlite3_bind_int(sqlite->stmt , ema+1 , g_value_get_int(value) ); } else if( G_VALUE_TYPE(value) == G_TYPE_STRING ){ char * tmp = g_value_get_string(value); sqlite3_bind_text(sqlite->stmt , ema+1 , tmp , strlen(tmp), SQLITE_TRANSIENT ); } } } int ncols = sqlite3_column_count(sqlite->stmt); rc = sqlite3_step(sqlite->stmt); //! Print column information int i; while(rc == SQLITE_ROW) { for(i=0; i < ncols; i++) { GValue a = {0}; g_assert (!G_VALUE_HOLDS_STRING (&a)); int type = sqlite3_column_type(sqlite->stmt, i); if(type==SQLITE_INTEGER){ g_value_init (&a, G_TYPE_INT); int tmp = sqlite3_column_int(sqlite->stmt, i); g_value_set_int (&a, 1); } else if(type==SQLITE_FLOAT){ g_value_init (&a, G_TYPE_FLOAT); } else if(type==SQLITE_TEXT){ char *tmp = g_strdup_printf ("%s", sqlite3_column_text(sqlite->stmt, i) ); g_value_init (&a, G_TYPE_STRING); g_value_set_string (&a, tmp); g_free(tmp); } hasil = g_value_array_append(hasil,&a); } rc = sqlite3_step(sqlite->stmt); } } else{ fprintf(stderr, "sqlite3_prepare() : Error: %s\n", tail); } sqlite3_finalize(sqlite->stmt); return hasil; }
void fluts_pmt_stream_info_add_language(FluTsPmtStreamInfo *pmt_info, gchar *language) { GValue v = { 0, }; g_return_if_fail (FLUTS_IS_PMT_STREAM_INFO (pmt_info)); g_value_init (&v, G_TYPE_STRING); g_value_take_string (&v, language); g_value_array_append (pmt_info->languages, &v); g_value_unset (&v); }