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);
}
Пример #2
0
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;
}
Пример #3
0
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);
}
Пример #4
0
/**
 * 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);
}
Пример #5
0
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;
}
Пример #6
0
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);
}
Пример #7
0
/**
 * 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);
}
Пример #8
0
/*
 * 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;
}
Пример #9
0
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;
  }
}
Пример #10
0
/**
 * 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);
}
Пример #11
0
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);
	}
}
Пример #13
0
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;
		}
	}
}
Пример #14
0
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);
}
Пример #15
0
/* 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;
}
Пример #16
0
/**
 * 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;
}
Пример #17
0
/**
 * 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;
}
Пример #18
0
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;
    }
}
Пример #19
0
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);
}
Пример #21
0
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;
}
Пример #22
0
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;
}
Пример #23
0
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;
}
Пример #24
0
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;
}
Пример #25
0
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);
}
Пример #27
0
/**
 * 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;
}
Пример #28
0
Файл: table.c Проект: gbl/vte
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);
}
Пример #29
0
/*
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;
}
Пример #30
0
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);
}