void data_link_forregex(struct data_link *dlink, Regex re, guint entry_no,
GFunc func, gpointer user_data)
{
GList *data_list;
gpointer key;
guint off;
GList *list;
if (re == NULL) {
data_link_foreach(dlink, func, user_data);
return;
}
if (dlink == NULL)
return;
if (entry_no >= dlink->nentries)
return;
off = dlink->entries[entry_no].off;
data_list = g_hash_table_get_values(dlink->entries->ht);
for (list = data_list; list != NULL; list = list->next) {
key = G_STRUCT_MEMBER_P(list->data, off);
if (re_ismatch(re, *(gchar **) key))
func(list->data, user_data);
}
g_list_free(data_list);
}
/**
* g_closure_new_simple:
* @sizeof_closure: the size of the structure to allocate, must be at least
* <literal>sizeof (GClosure)</literal>
* @data: data to store in the @data field of the newly allocated #GClosure
*
* Allocates a struct of the given size and initializes the initial
* part as a #GClosure. This function is mainly useful when
* implementing new types of closures.
*
* |[
* typedef struct _MyClosure MyClosure;
* struct _MyClosure
* {
* GClosure closure;
* // extra data goes here
* };
*
* static void
* my_closure_finalize (gpointer notify_data,
* GClosure *closure)
* {
* MyClosure *my_closure = (MyClosure *)closure;
*
* // free extra data here
* }
*
* MyClosure *my_closure_new (gpointer data)
* {
* GClosure *closure;
* MyClosure *my_closure;
*
* closure = g_closure_new_simple (sizeof (MyClosure), data);
* my_closure = (MyClosure *) closure;
*
* // initialize extra data here
*
* g_closure_add_finalize_notifier (closure, notify_data,
* my_closure_finalize);
* return my_closure;
* }
* ]|
*
* Returns: (transfer full): a newly allocated #GClosure
*/
GClosure*
g_closure_new_simple (guint sizeof_closure,
gpointer data)
{
GClosure *closure;
g_return_val_if_fail (sizeof_closure >= sizeof (GClosure), NULL);
closure = g_malloc0 (sizeof_closure);
SET (closure, ref_count, 1);
SET (closure, meta_marshal, 0);
SET (closure, n_guards, 0);
SET (closure, n_fnotifiers, 0);
SET (closure, n_inotifiers, 0);
SET (closure, in_inotify, FALSE);
SET (closure, floating, TRUE);
SET (closure, derivative_flag, 0);
SET (closure, in_marshal, FALSE);
SET (closure, is_invalid, FALSE);
closure->marshal = NULL;
closure->data = data;
closure->notifiers = NULL;
memset (G_STRUCT_MEMBER_P (closure, sizeof (*closure)), 0, sizeof_closure - sizeof (*closure));
return closure;
}
GstVaapiDecodeH264Private *
gst_vaapi_decode_h264_get_instance_private (gpointer self)
{
if (h264_private_offset == 0)
return NULL;
return (G_STRUCT_MEMBER_P (self, h264_private_offset));
}
void
chanopt_load (session *sess)
{
int i;
guint8 val;
chanopt_in_memory *co;
char *network;
if (sess->channel[0] == 0)
return;
network = server_get_network (sess->server, FALSE);
if (!network)
return;
if (!chanopt_open)
{
chanopt_open = TRUE;
chanopt_load_all ();
}
co = chanopt_find (network, sess->channel, FALSE);
if (!co)
return;
/* fill in all the sess->xxxxx fields */
i = 0;
while (i < sizeof (chanopt) / sizeof (channel_options))
{
val = G_STRUCT_MEMBER(guint8, co, chanopt[i].offset);
*(guint8 *)G_STRUCT_MEMBER_P(sess, chanopt[i].offset) = val;
i++;
}
}
static void term_fill_capabilities(TERM_REC *term)
{
int i, ival;
char *sval;
void *ptr;
#ifndef HAVE_TERMINFO
char *tptr = term->buffer2;
#endif
for (i = 0; i < sizeof(tcaps)/sizeof(tcaps[0]); i++) {
ptr = G_STRUCT_MEMBER_P(term, tcaps[i].offset);
switch (tcaps[i].type) {
case CAP_TYPE_FLAG:
ival = term_getflag(tcaps[i]);
*(int *)ptr = ival;
break;
case CAP_TYPE_INT:
ival = term_getnum(tcaps[i]);
*(int *)ptr = ival;
break;
case CAP_TYPE_STR:
sval = term_getstr(tcaps[i], tptr);
if (sval == (char *) -1)
*(char **)ptr = NULL;
else
*(char **)ptr = sval;
break;
}
}
}
void
chanopt_save (session *sess)
{
int i;
guint8 vals;
guint8 valm;
chanopt_in_memory *co;
char *network;
if (sess->channel[0] == 0)
return;
network = server_get_network (sess->server, FALSE);
if (!network)
return;
/* 2. reconcile sess with what we loaded from disk */
co = chanopt_find (network, sess->channel, TRUE);
i = 0;
while (i < sizeof (chanopt) / sizeof (channel_options))
{
vals = G_STRUCT_MEMBER(guint8, sess, chanopt[i].offset);
valm = G_STRUCT_MEMBER(guint8, co, chanopt[i].offset);
if (vals != valm)
{
*(guint8 *)G_STRUCT_MEMBER_P(co, chanopt[i].offset) = vals;
chanopt_changed = TRUE;
}
i++;
}
}
/* --- functions --- */
GClosure*
g_closure_new_simple (guint sizeof_closure,
gpointer data)
{
GClosure *closure;
g_return_val_if_fail (sizeof_closure >= sizeof (GClosure), NULL);
closure = g_malloc (sizeof_closure);
closure->ref_count = 1;
closure->meta_marshal = 0;
closure->n_guards = 0;
closure->n_fnotifiers = 0;
closure->n_inotifiers = 0;
closure->in_inotify = FALSE;
closure->floating = TRUE;
closure->derivative_flag = 0;
closure->in_marshal = FALSE;
closure->is_invalid = FALSE;
closure->marshal = NULL;
closure->data = data;
closure->notifiers = NULL;
memset (G_STRUCT_MEMBER_P (closure, sizeof (*closure)), 0, sizeof_closure - sizeof (*closure));
return closure;
}
static void dict_to_struct (GHashTable *dict,
const DictFieldMapping *mapping,
void *struct_ptr)
{
const DictFieldMapping *it = mapping;
g_return_if_fail (it != NULL);
while (it->name != NULL) {
switch (it->type) {
case G_TYPE_INT64: {
gint *field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
*field = get_int64 (dict, it->name);
break;
}
case G_TYPE_BOOLEAN: {
gboolean *field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
*field = get_boolean (dict, it->name);
break;
}
case G_TYPE_STRING: {
gchar **field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
*field = get_string (dict, it->name);
break;
}
case G_TYPE_DOUBLE: {
gdouble *field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
*field = get_double (dict, it->name);
break;
}
}
g_hash_table_remove (dict, it->name);
++it;
}
#ifdef DEBUG_PARSING
if (g_hash_table_size (dict) != 0) {
g_print ("Unused keys:\n");
g_hash_table_foreach (dict, dump_key_name, NULL);
g_print ("\n");
}
#endif
}
static void init_spin(GtkBuilder* b, const char* name, gsize off, const char* changed_notify)
{
GtkSpinButton* btn = GTK_SPIN_BUTTON(gtk_builder_get_object(b, name));
guint* val = (guint*)G_STRUCT_MEMBER_P(fm_config, off);
if(changed_notify)
g_object_set_data_full(G_OBJECT(btn), "changed", g_strdup(changed_notify), g_free);
gtk_spin_button_set_value(btn, *val);
g_signal_connect(btn, "value-changed", G_CALLBACK(on_spin_changed), GSIZE_TO_POINTER(off));
}
static void init_combo(GtkBuilder* builder, const char* name, gsize off, const char* changed_notify)
{
GtkComboBox* combo = (GtkComboBox*)gtk_builder_get_object(builder, name);
int* val = (int*)G_STRUCT_MEMBER_P(fm_config, off);
if(changed_notify)
g_object_set_data_full(G_OBJECT(combo), "changed", g_strdup(changed_notify), g_free);
gtk_combo_box_set_active(combo, *val);
g_signal_connect(combo, "changed", G_CALLBACK(on_combo_changed), GSIZE_TO_POINTER(off));
}
static void init_entry(GtkBuilder* b, const char* name, gsize off, const char* changed_notify)
{
GtkEntry* btn = GTK_ENTRY(gtk_builder_get_object(b, name));
gchar** val = (gchar**)G_STRUCT_MEMBER_P(fm_config, off);
if(changed_notify)
g_object_set_data_full(G_OBJECT(btn), "changed", g_strdup(changed_notify), g_free);
if(*val)
gtk_entry_set_text(btn, *val);
g_signal_connect(btn, "changed", G_CALLBACK(on_entry_changed), GSIZE_TO_POINTER(off));
}
static gboolean
mateconf_backend_verify_vtable (MateConfBackendVTable *vtable,
MateConfBackendVTable *vtable_copy,
const char *backend_name,
GError **err)
{
int i;
struct
{
char *name;
gsize offset;
} required_vtable_functions[] = {
{ "shutdown", G_STRUCT_OFFSET(MateConfBackendVTable, shutdown) },
{ "resolve_address", G_STRUCT_OFFSET(MateConfBackendVTable, resolve_address) },
{ "query_value", G_STRUCT_OFFSET(MateConfBackendVTable, query_value) },
{ "query_metainfo", G_STRUCT_OFFSET(MateConfBackendVTable, query_metainfo) },
{ "set_value", G_STRUCT_OFFSET(MateConfBackendVTable, set_value) },
{ "all_entries", G_STRUCT_OFFSET(MateConfBackendVTable, all_entries) },
{ "all_subdirs", G_STRUCT_OFFSET(MateConfBackendVTable, all_subdirs) },
{ "unset_value", G_STRUCT_OFFSET(MateConfBackendVTable, unset_value) },
{ "dir_exists", G_STRUCT_OFFSET(MateConfBackendVTable, dir_exists) },
{ "remove_dir", G_STRUCT_OFFSET(MateConfBackendVTable, remove_dir) },
{ "set_schema", G_STRUCT_OFFSET(MateConfBackendVTable, set_schema) },
{ "sync_all", G_STRUCT_OFFSET(MateConfBackendVTable, sync_all) },
{ "destroy_source", G_STRUCT_OFFSET(MateConfBackendVTable, destroy_source) },
{ "blow_away_locks", G_STRUCT_OFFSET(MateConfBackendVTable, blow_away_locks) }
};
if (!vtable)
{
mateconf_set_error(err,
MATECONF_ERROR_FAILED, _("Backend `%s' failed return a vtable\n"),
backend_name);
return FALSE;
}
/* Create a copy in case vtable size doesn't match */
memcpy(vtable_copy, vtable, MIN(vtable->vtable_size, sizeof(MateConfBackendVTable)));
vtable_copy->vtable_size = sizeof(MateConfBackendVTable);
for (i = 0; i < G_N_ELEMENTS(required_vtable_functions); i++)
{
if (G_STRUCT_MEMBER_P(vtable_copy, required_vtable_functions[i].offset) == NULL)
{
mateconf_set_error(err,
MATECONF_ERROR_FAILED, _("Backend `%s' missing required vtable member `%s'\n"),
backend_name,
required_vtable_functions[i].name);
return FALSE;
}
}
return TRUE;
}
static void data_link_unlink(struct data_link *dlink, gpointer data)
{
struct data_link_entry_wrap *entry;
gpointer key;
guint n;
entry = dlink->entries;
for (n = 0; n < dlink->nentries; n++, entry++) {
key = G_STRUCT_MEMBER_P(data, entry->off);
g_hash_table_remove(entry->ht, key);
}
}
static void init_bool(GtkBuilder* b, const char* name, gsize off,
const char* changed_notify, gboolean force_show)
{
GtkToggleButton* btn = GTK_TOGGLE_BUTTON(gtk_builder_get_object(b, name));
gboolean* val = (gboolean*)G_STRUCT_MEMBER_P(fm_config, off);
if(changed_notify)
g_object_set_data_full(G_OBJECT(btn), "changed", g_strdup(changed_notify), g_free);
if(force_show)
gtk_widget_show(GTK_WIDGET(btn));
gtk_toggle_button_set_active(btn, *val);
g_signal_connect(btn, "toggled", G_CALLBACK(on_toggled), GSIZE_TO_POINTER(off));
}
static void dump_struct (const DictFieldMapping *mapping,
void *struct_ptr)
{
const DictFieldMapping *it = mapping;
g_return_if_fail (it != NULL);
while (it->name != NULL) {
switch (it->type) {
case G_TYPE_INT64: {
gint *field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
g_print ("%s: %d\n", it->name, *field);
break;
}
case G_TYPE_BOOLEAN: {
gboolean *field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
g_print ("%s: %s\n", it->name, (*field)?"true":"false");
break;
}
case G_TYPE_STRING: {
gchar **field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
g_print ("%s: %s\n", it->name, *field);
break;
}
case G_TYPE_DOUBLE: {
gdouble *field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
g_print ("%s: %f\n", it->name, *field);
break;
}
}
++it;
}
}
static void on_spin_changed(GtkSpinButton* btn, gpointer _off)
{
gsize off = GPOINTER_TO_SIZE(_off);
guint* val = (guint*)G_STRUCT_MEMBER_P(fm_config, off);
guint new_val = gtk_spin_button_get_value(btn);
if(*val != new_val)
{
const char* name = g_object_get_data((GObject*)btn, "changed");
if(!name)
name = gtk_buildable_get_name((GtkBuildable*)btn);
*val = new_val;
fm_config_emit_changed(fm_config, name);
}
}
static void on_toggled(GtkToggleButton* btn, gpointer _off)
{
gsize off = GPOINTER_TO_SIZE(_off);
gboolean* val = (gboolean*)G_STRUCT_MEMBER_P(fm_config, off);
gboolean new_val = gtk_toggle_button_get_active(btn);
if(*val != new_val)
{
const char* name = g_object_get_data((GObject*)btn, "changed");
if(!name)
name = gtk_buildable_get_name((GtkBuildable*)btn);
*val = new_val;
fm_config_emit_changed(fm_config, name);
}
}
static void free_struct (const DictFieldMapping *mapping,
void *struct_ptr)
{
const DictFieldMapping *it = mapping;
while (it->name != NULL) {
if (it->type == G_TYPE_STRING) {
gchar **field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
g_free (*field);
}
++it;
}
g_free (struct_ptr);
}
static void on_combo_changed(GtkComboBox* combo, gpointer _off)
{
gsize off = GPOINTER_TO_SIZE(_off);
int* val = (int*)G_STRUCT_MEMBER_P(fm_config, off);
int sel = gtk_combo_box_get_active(combo);
if(sel != *val)
{
const char* name = g_object_get_data((GObject*)combo, "changed");
if(!name)
name = gtk_buildable_get_name((GtkBuildable*)combo);
*val = sel;
fm_config_emit_changed(fm_config, name);
}
}
static void on_entry_changed(GtkEntry* entry, gpointer _off)
{
gsize off = GPOINTER_TO_SIZE(_off);
gchar** val = (gchar**)G_STRUCT_MEMBER_P(fm_config, off);
const char* new_val = gtk_entry_get_text(entry);
if(g_strcmp0(*val, new_val))
{
const char* name = g_object_get_data((GObject*)entry, "changed");
if(!name)
name = gtk_buildable_get_name((GtkBuildable*)entry);
g_free(*val);
*val = *new_val ? g_strdup(new_val) : NULL;
fm_config_emit_changed(fm_config, name);
}
}
static void
chanopt_add_opt (chanopt_in_memory *co, char *var, int new_value)
{
int i;
i = 0;
while (i < sizeof (chanopt) / sizeof (channel_options))
{
if (!strcmp (var, chanopt[i].name))
{
*(guint8 *)G_STRUCT_MEMBER_P(co, chanopt[i].offset) = new_value;
}
i++;
}
}
static void on_icon_size_changed(GtkComboBox* combo, gpointer _off)
{
GtkTreeIter it;
if(gtk_combo_box_get_active_iter(combo, &it))
{
gsize off = GPOINTER_TO_SIZE(_off);
int* val = (int*)G_STRUCT_MEMBER_P(fm_config, off);
int size;
GtkTreeModel* model = gtk_combo_box_get_model(combo);
gtk_tree_model_get(model, &it, 1, &size, -1);
if(size != *val)
{
const char* name = gtk_buildable_get_name((GtkBuildable*)combo);
*val = size;
fm_config_emit_changed(fm_config, name);
}
}
}
static void init_icon_sizes(GtkBuilder* builder, const char* name, gsize off)
{
GtkComboBox* combo = (GtkComboBox*)gtk_builder_get_object(builder, name);
GtkTreeModel* model = gtk_combo_box_get_model(combo);
GtkTreeIter it;
int* val = (int*)G_STRUCT_MEMBER_P(fm_config, off);
gtk_tree_model_get_iter_first(model, &it);
gtk_combo_box_set_active_iter(combo, &it);
do{
int size;
gtk_tree_model_get(model, &it, 1, &size, -1);
if(size == *val)
{
gtk_combo_box_set_active_iter(combo, &it);
break;
}
}while(gtk_tree_model_iter_next(model, &it));
g_signal_connect(combo, "changed", G_CALLBACK(on_icon_size_changed), GSIZE_TO_POINTER(off));
}
static chanopt_in_memory *
chanopt_find (char *network, char *channel, gboolean add_new)
{
GSList *list;
chanopt_in_memory *co;
int i;
for (list = chanopt_list; list; list = list->next)
{
co = list->data;
if (!g_ascii_strcasecmp (co->channel, channel) &&
!g_ascii_strcasecmp (co->network, network))
return co;
}
if (!add_new)
return NULL;
/* allocate a new one */
co = g_malloc0 (sizeof (chanopt_in_memory));
co->channel = g_strdup (channel);
co->network = g_strdup (network);
/* set all values to SET_DEFAULT */
i = 0;
while (i < sizeof (chanopt) / sizeof (channel_options))
{
*(guint8 *)G_STRUCT_MEMBER_P(co, chanopt[i].offset) = SET_DEFAULT;
i++;
}
chanopt_list = g_slist_prepend (chanopt_list, co);
chanopt_changed = TRUE;
return co;
}
static gboolean
pk_backend_config_set_list (PkBackendConfig *config, const gchar *option,
const gchar *words)
{
gsize i;
g_return_val_if_fail (config != NULL, FALSE);
g_return_val_if_fail (option != NULL, FALSE);
g_return_val_if_fail (words != NULL, FALSE);
for (i = 0;; ++i) {
const gchar *name = pk_backend_config_list_options[i].name;
gint cmp = g_strcmp0 (option, name);
if (name == NULL || cmp < 0) {
return FALSE;
} else if (cmp == 0) {
glong offset = pk_backend_config_list_options[i].offset;
alpm_list_t **list = G_STRUCT_MEMBER_P (config, offset);
*list = alpm_list_add_words (*list, words);
return TRUE;
}
}
}
/**
* g_field_info_get_field: (skip)
* @field_info: a #GIFieldInfo
* @mem: pointer to a block of memory representing a C structure or union
* @value: a #GIArgument into which to store the value retrieved
*
* Reads a field identified by a #GFieldInfo from a C structure or
* union. This only handles fields of simple C types. It will fail
* for a field of a composite type like a nested structure or union
* even if that is actually readable.
*
* Returns: %TRUE if reading the field succeeded, otherwise %FALSE
*/
gboolean
g_field_info_get_field (GIFieldInfo *field_info,
gpointer mem,
GIArgument *value)
{
int offset;
GITypeInfo *type_info;
gboolean result = FALSE;
g_return_val_if_fail (field_info != NULL, FALSE);
g_return_val_if_fail (GI_IS_FIELD_INFO (field_info), FALSE);
if ((g_field_info_get_flags (field_info) & GI_FIELD_IS_READABLE) == 0)
return FALSE;
offset = g_field_info_get_offset (field_info);
type_info = g_field_info_get_type (field_info);
if (g_type_info_is_pointer (type_info))
{
value->v_pointer = G_STRUCT_MEMBER (gpointer, mem, offset);
result = TRUE;
}
else
{
switch (g_type_info_get_tag (type_info))
{
case GI_TYPE_TAG_VOID:
g_warning("Field %s: should not be have void type",
g_base_info_get_name ((GIBaseInfo *)field_info));
break;
case GI_TYPE_TAG_BOOLEAN:
value->v_boolean = G_STRUCT_MEMBER (gboolean, mem, offset) != FALSE;
result = TRUE;
break;
case GI_TYPE_TAG_INT8:
case GI_TYPE_TAG_UINT8:
value->v_uint8 = G_STRUCT_MEMBER (guint8, mem, offset);
result = TRUE;
break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_UINT16:
value->v_uint16 = G_STRUCT_MEMBER (guint16, mem, offset);
result = TRUE;
break;
case GI_TYPE_TAG_INT32:
case GI_TYPE_TAG_UINT32:
case GI_TYPE_TAG_UNICHAR:
value->v_uint32 = G_STRUCT_MEMBER (guint32, mem, offset);
result = TRUE;
break;
case GI_TYPE_TAG_INT64:
case GI_TYPE_TAG_UINT64:
value->v_uint64 = G_STRUCT_MEMBER (guint64, mem, offset);
result = TRUE;
break;
case GI_TYPE_TAG_GTYPE:
value->v_size = G_STRUCT_MEMBER (gsize, mem, offset);
result = TRUE;
break;
case GI_TYPE_TAG_FLOAT:
value->v_float = G_STRUCT_MEMBER (gfloat, mem, offset);
result = TRUE;
break;
case GI_TYPE_TAG_DOUBLE:
value->v_double = G_STRUCT_MEMBER (gdouble, mem, offset);
result = TRUE;
break;
case GI_TYPE_TAG_ARRAY:
/* We don't check the array type and that it is fixed-size,
we trust g-ir-compiler to do the right thing */
value->v_pointer = G_STRUCT_MEMBER_P (mem, offset);
result = TRUE;
break;
case GI_TYPE_TAG_UTF8:
case GI_TYPE_TAG_FILENAME:
case GI_TYPE_TAG_GLIST:
case GI_TYPE_TAG_GSLIST:
case GI_TYPE_TAG_GHASH:
g_warning("Field %s: type %s should have is_pointer set",
g_base_info_get_name ((GIBaseInfo *)field_info),
g_type_tag_to_string (g_type_info_get_tag (type_info)));
break;
case GI_TYPE_TAG_ERROR:
/* Needs to be handled by the language binding directly */
break;
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *interface = g_type_info_get_interface (type_info);
switch (g_base_info_get_type (interface))
{
case GI_INFO_TYPE_STRUCT:
case GI_INFO_TYPE_UNION:
case GI_INFO_TYPE_BOXED:
/* Needs to be handled by the language binding directly */
break;
case GI_INFO_TYPE_OBJECT:
break;
case GI_INFO_TYPE_ENUM:
case GI_INFO_TYPE_FLAGS:
{
/* FIXME: there's a mismatch here between the value->v_int we use
* here and the gint64 result returned from g_value_info_get_value().
* But to switch this to gint64, we'd have to make g_function_info_invoke()
* translate value->v_int64 to the proper ABI for an enum function
* call parameter, which will usually be int, and then fix up language
* bindings.
*/
GITypeTag storage_type = g_enum_info_get_storage_type ((GIEnumInfo *)interface);
switch (storage_type)
{
case GI_TYPE_TAG_INT8:
case GI_TYPE_TAG_UINT8:
value->v_int = (gint)G_STRUCT_MEMBER (guint8, mem, offset);
result = TRUE;
break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_UINT16:
value->v_int = (gint)G_STRUCT_MEMBER (guint16, mem, offset);
result = TRUE;
break;
case GI_TYPE_TAG_INT32:
case GI_TYPE_TAG_UINT32:
value->v_int = (gint)G_STRUCT_MEMBER (guint32, mem, offset);
result = TRUE;
break;
case GI_TYPE_TAG_INT64:
case GI_TYPE_TAG_UINT64:
value->v_int = (gint)G_STRUCT_MEMBER (guint64, mem, offset);
result = TRUE;
break;
default:
g_warning("Field %s: Unexpected enum storage type %s",
g_base_info_get_name ((GIBaseInfo *)field_info),
g_type_tag_to_string (storage_type));
break;
}
break;
}
case GI_INFO_TYPE_VFUNC:
case GI_INFO_TYPE_CALLBACK:
g_warning("Field %s: Interface type %d should have is_pointer set",
g_base_info_get_name ((GIBaseInfo *)field_info),
g_base_info_get_type (interface));
break;
case GI_INFO_TYPE_INVALID:
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_FUNCTION:
case GI_INFO_TYPE_CONSTANT:
case GI_INFO_TYPE_INVALID_0:
case GI_INFO_TYPE_VALUE:
case GI_INFO_TYPE_SIGNAL:
case GI_INFO_TYPE_PROPERTY:
case GI_INFO_TYPE_FIELD:
case GI_INFO_TYPE_ARG:
case GI_INFO_TYPE_TYPE:
case GI_INFO_TYPE_UNRESOLVED:
g_warning("Field %s: Interface type %d not expected",
g_base_info_get_name ((GIBaseInfo *)field_info),
g_base_info_get_type (interface));
break;
}
g_base_info_unref ((GIBaseInfo *)interface);
break;
}
break;
}
}
g_base_info_unref ((GIBaseInfo *)type_info);
return result;
}
static void
implement_interface_methods (gpointer iface,
GType proxy_type)
{
GType exten_type = G_TYPE_FROM_INTERFACE (iface);
guint i;
GArray *impls;
g_debug ("Implementing interface '%s' for proxy type '%s'",
g_type_name (exten_type), g_type_name (proxy_type));
impls = g_type_get_qdata (exten_type, method_impl_quark ());
if (impls == NULL)
{
GIInterfaceInfo *iface_info;
guint n_vfuncs;
iface_info = g_irepository_find_by_gtype (NULL, exten_type);
g_return_if_fail (iface_info != NULL);
g_return_if_fail (g_base_info_get_type (iface_info) == GI_INFO_TYPE_INTERFACE);
n_vfuncs = g_interface_info_get_n_vfuncs (iface_info);
impls = g_array_new (FALSE, TRUE, sizeof (MethodImpl));
g_array_set_size (impls, n_vfuncs);
for (i = 0; i < n_vfuncs; i++)
{
GIVFuncInfo *vfunc_info;
vfunc_info = g_interface_info_get_vfunc (iface_info, i);
create_native_closure (exten_type, iface_info,
vfunc_info,
&g_array_index (impls, MethodImpl, i));
g_base_info_unref (vfunc_info);
}
g_type_set_qdata (exten_type, method_impl_quark (), impls);
g_base_info_unref (iface_info);
}
for (i = 0; i < impls->len; i++)
{
MethodImpl *impl = &g_array_index (impls, MethodImpl, i);
gpointer *method_ptr;
if (impl->closure == NULL)
continue;
method_ptr = G_STRUCT_MEMBER_P (iface, impl->struct_offset);
*method_ptr = impl->closure;
g_debug ("Implemented '%s.%s' at %d (%p) with %p",
g_type_name (exten_type), impl->method_name,
impl->struct_offset, method_ptr, impl->closure);
}
g_debug ("Implemented interface '%s' for '%s' proxy",
g_type_name (exten_type), g_type_name (proxy_type));
}
static gboolean
kms_base_hub_link_sink_pad (KmsBaseHub * mixer, gint id,
const gchar * gp_name, const gchar * gp_template_name,
GstElement * internal_element, const gchar * pad_name,
const gchar * port_src_pad_name, gulong target_offset,
gboolean remove_on_unlink)
{
KmsBaseHubPortData *port_data;
gboolean ret;
GstPad *gp, *target;
GstPad **port_data_target;
if (GST_OBJECT_PARENT (internal_element) != GST_OBJECT (mixer)) {
GST_ERROR_OBJECT (mixer, "Cannot link %" GST_PTR_FORMAT " wrong hierarchy",
internal_element);
return FALSE;
}
target = gst_element_get_static_pad (internal_element, pad_name);
if (target == NULL) {
target = gst_element_get_request_pad (internal_element, pad_name);
if (target != NULL && remove_on_unlink) {
g_signal_connect (G_OBJECT (target), "unlinked",
G_CALLBACK (remove_unlinked_pad), NULL);
}
}
if (target == NULL) {
GST_ERROR_OBJECT (mixer, "Cannot get target pad");
return FALSE;
}
KMS_BASE_HUB_LOCK (mixer);
port_data = g_hash_table_lookup (mixer->priv->ports, &id);
if (port_data == NULL) {
ret = FALSE;
goto end;
}
port_data_target = G_STRUCT_MEMBER_P (port_data, target_offset);
if (*port_data_target != NULL) {
g_clear_object (port_data_target);
}
*port_data_target = g_object_ref (target);
gp = gst_element_get_static_pad (GST_ELEMENT (mixer), gp_name);
if (gp != NULL) {
ret = set_target (gp, target);
g_object_unref (gp);
} else {
GstPad *src_pad = gst_element_get_static_pad (port_data->port,
port_src_pad_name);
if (src_pad != NULL) {
ret = kms_base_hub_create_and_link_ghost_pad (mixer, src_pad,
gp_name, gp_template_name, target);
g_object_unref (src_pad);
} else {
ret = TRUE;
}
}
GST_DEBUG_OBJECT (mixer, "Audio target pad for port %d: %" GST_PTR_FORMAT,
port_data->id, port_data->audio_sink_target);
GST_DEBUG_OBJECT (mixer, "Video target pad for port %d: %" GST_PTR_FORMAT,
port_data->id, port_data->video_sink_target);
end:
KMS_BASE_HUB_UNLOCK (mixer);
g_object_unref (target);
return ret;
}
int
chanopt_command (session *sess, char *tbuf, char *word[], char *word_eol[])
{
int dots, i = 0, j, p = 0;
guint8 val;
int offset = 2;
char *find;
gboolean quiet = FALSE;
int newval = -1;
if (!strcmp (word[2], "-quiet"))
{
quiet = TRUE;
offset++;
}
find = word[offset++];
if (word[offset][0])
{
if (!g_ascii_strcasecmp (word[offset], "ON"))
newval = 1;
else if (!g_ascii_strcasecmp (word[offset], "OFF"))
newval = 0;
else if (word[offset][0] == 'u')
newval = SET_DEFAULT;
else
newval = atoi (word[offset]);
}
if (!quiet)
PrintTextf (sess, "\002Network\002: %s \002Channel\002: %s\n",
sess->server->network ? server_get_network (sess->server, TRUE) : _("<none>"),
sess->channel[0] ? sess->channel : _("<none>"));
while (i < sizeof (chanopt) / sizeof (channel_options))
{
if (find[0] == 0 || match (find, chanopt[i].name) || (chanopt[i].alias && match (find, chanopt[i].alias)))
{
if (newval != -1) /* set new value */
{
*(guint8 *)G_STRUCT_MEMBER_P(sess, chanopt[i].offset) = newval;
}
if (!quiet) /* print value */
{
strcpy (tbuf, chanopt[i].name);
p = strlen (tbuf);
tbuf[p++] = 3;
tbuf[p++] = '2';
dots = 20 - strlen (chanopt[i].name);
for (j = 0; j < dots; j++)
tbuf[p++] = '.';
tbuf[p++] = 0;
val = G_STRUCT_MEMBER (guint8, sess, chanopt[i].offset);
PrintTextf (sess, "%s\0033:\017 %s", tbuf, chanopt_value (val));
}
}
i++;
}
return TRUE;
}
