| /* |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| /* |
| * Copyright (c) 2011-2012, Freescale Semiconductor, Inc. All rights reserved. |
| * |
| */ |
| |
| /* |
| * Module Name: gstsutils.c |
| * |
| * Description: simple utils for gst plugins |
| * |
| * Portability: This code is written for Linux OS and Gstreamer |
| */ |
| |
| /* |
| * Changelog: |
| * |
| */ |
| |
| #include <string.h> |
| #include "gstsutils.h" |
| |
| typedef struct _GstsutilsData |
| { |
| char * key; |
| char * value; |
| }GstsutilsData; |
| struct _GstsutilsGroup |
| { |
| GstsutilsData ** data; |
| gint num; |
| gchar * name; |
| }; |
| struct _GstsutilsEntry |
| { |
| GstsutilsGroup ** group; |
| gint num; |
| }; |
| |
| static gboolean |
| g_string_to_boolean (const gchar * str) |
| { |
| if ((str) && ((strcmp (str, "true") == 0) || (strcmp (str, "TRUE") == 0))) { |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| |
| void |
| gstsutils_options_install_properties_by_options (GstsutilsOptionEntry * table, |
| GObjectClass * oclass) |
| { |
| #define GSTSUTILS_INSTALL_PROPERTY(basetype) \ |
| do { \ |
| g_object_class_install_property (oclass, p->id, \ |
| g_param_spec_##basetype (p->name, p->nickname, \ |
| p->desc, \ |
| (g##basetype) g_ascii_strtoll (p->min, NULL, 0), \ |
| (g##basetype) g_ascii_strtoll (p->max, NULL, 0), \ |
| (g##basetype) g_ascii_strtoll (p->def, NULL, 0), G_PARAM_READWRITE)); \ |
| }while(0) |
| |
| GstsutilsOptionEntry *p = table; |
| while (p->id >= 0) { |
| switch (p->gtype) { |
| case (G_TYPE_BOOLEAN): |
| g_object_class_install_property (oclass, p->id, |
| g_param_spec_boolean (p->name, p->nickname, |
| p->desc, g_string_to_boolean (p->def), G_PARAM_READWRITE)); |
| break; |
| case (G_TYPE_INT): |
| GSTSUTILS_INSTALL_PROPERTY (int); |
| break; |
| case (G_TYPE_UINT): |
| GSTSUTILS_INSTALL_PROPERTY (uint); |
| break; |
| case (G_TYPE_LONG): |
| GSTSUTILS_INSTALL_PROPERTY (long); |
| break; |
| case (G_TYPE_ULONG): |
| GSTSUTILS_INSTALL_PROPERTY (ulong); |
| break; |
| case (G_TYPE_INT64): |
| GSTSUTILS_INSTALL_PROPERTY (int64); |
| break; |
| case (G_TYPE_UINT64): |
| GSTSUTILS_INSTALL_PROPERTY (uint64); |
| break; |
| case (G_TYPE_DOUBLE): |
| g_object_class_install_property (oclass, p->id, |
| g_param_spec_double (p->name, p->nickname, |
| p->desc, |
| g_strtod (p->min, NULL), |
| g_strtod (p->max, NULL), |
| g_strtod (p->def, NULL), G_PARAM_READWRITE)); |
| break; |
| |
| case (G_TYPE_STRING): |
| g_object_class_install_property (oclass, p->id, |
| g_param_spec_string (p->name, p->nickname, p->desc, p->def, |
| G_PARAM_READWRITE)); |
| break; |
| case (G_TYPE_ENUM): |
| { |
| g_object_class_install_property (oclass, p->id, |
| g_param_spec_enum (p->name, p->nickname, p->desc, p->typefunc (), |
| (gint) (g_ascii_strtoll (p->def, NULL, 0)), G_PARAM_READWRITE)); |
| |
| break; |
| } |
| default: |
| break; |
| }; |
| p++; |
| }; |
| } |
| |
| |
| static GstsutilsOptionEntry * |
| gstsutils_options_search_option_by_id (GstsutilsOptionEntry * table, gint id) |
| { |
| if (table) { |
| while (table->id != -1) { |
| if (table->id == id) { |
| return table; |
| } |
| table++; |
| } |
| } |
| return NULL; |
| } |
| |
| |
| void |
| gstsutils_set_value (gchar * target, GstsutilsOptionEntry * p, |
| const gchar * svalue) |
| { |
| #define GSTSUTILS_CHECK_AND_SET_VALUE(basetype) \ |
| do { \ |
| if (svalue){ \ |
| g##basetype value = (g##basetype) g_ascii_strtoll(svalue, NULL, 0); \ |
| if ((value>=(g##basetype) g_ascii_strtoll(p->min, NULL, 0)) \ |
| && (value<=(g##basetype) g_ascii_strtoll(p->max, NULL, 0))){ \ |
| *(g##basetype *)(target+p->offset) = value; \ |
| } \ |
| } \ |
| }while(0) |
| switch (p->gtype) { |
| case (G_TYPE_BOOLEAN): |
| if (svalue) { |
| *(gboolean *) (target + p->offset) = g_string_to_boolean (svalue); |
| } |
| break; |
| case (G_TYPE_INT): |
| GSTSUTILS_CHECK_AND_SET_VALUE (int); |
| break; |
| case (G_TYPE_UINT): |
| GSTSUTILS_CHECK_AND_SET_VALUE (uint); |
| break; |
| case (G_TYPE_LONG): |
| GSTSUTILS_CHECK_AND_SET_VALUE (long); |
| break; |
| case (G_TYPE_ULONG): |
| GSTSUTILS_CHECK_AND_SET_VALUE (ulong); |
| break; |
| case (G_TYPE_INT64): |
| GSTSUTILS_CHECK_AND_SET_VALUE (int64); |
| break; |
| case (G_TYPE_UINT64): |
| GSTSUTILS_CHECK_AND_SET_VALUE (uint64); |
| break; |
| case (G_TYPE_DOUBLE): |
| { |
| if (svalue) { |
| gdouble value = g_strtod (svalue, NULL); |
| if ((value >= g_strtod (p->min, NULL)) |
| && (value <= g_strtod (p->max, NULL))) { |
| *(gdouble *) (target + p->offset) = value; |
| } |
| } |
| break; |
| } |
| case (G_TYPE_STRING): |
| { |
| gchar *value = *(gchar **) (target + p->offset); |
| if (value) { |
| g_free (value); |
| *(gchar **) (target + p->offset) = NULL; |
| } |
| if (svalue) { |
| value = g_strdup (svalue); |
| if (value) { |
| *(gchar **) (target + p->offset) = value; |
| } |
| } |
| break; |
| } |
| case (G_TYPE_ENUM): |
| { |
| gint value = (gint) g_ascii_strtoll (svalue, NULL, 0); |
| *(gint *) (target + p->offset) = value; |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| |
| |
| gboolean |
| gstsutils_options_get_option (GstsutilsOptionEntry * table, gchar * option, |
| guint id, GValue * value) |
| { |
| #define GSTSUTILS_GETVALUE(basetype) \ |
| do { \ |
| g_value_set_##basetype (value, *(g##basetype *) (option + p->offset)); \ |
| }while(0) |
| |
| gboolean ret = TRUE; |
| if ((value) && (option)) { |
| GstsutilsOptionEntry *p = gstsutils_options_search_option_by_id (table, id); |
| if (p) { |
| switch (p->gtype) { |
| case (G_TYPE_BOOLEAN): |
| GSTSUTILS_GETVALUE (boolean); |
| break; |
| case (G_TYPE_INT): |
| GSTSUTILS_GETVALUE (int); |
| break; |
| case (G_TYPE_UINT): |
| GSTSUTILS_GETVALUE (uint); |
| break; |
| case (G_TYPE_LONG): |
| GSTSUTILS_GETVALUE (ulong); |
| break; |
| case (G_TYPE_ULONG): |
| GSTSUTILS_GETVALUE (ulong); |
| break; |
| case (G_TYPE_INT64): |
| GSTSUTILS_GETVALUE (int64); |
| break; |
| case (G_TYPE_UINT64): |
| GSTSUTILS_GETVALUE (uint64); |
| break; |
| case (G_TYPE_DOUBLE): |
| GSTSUTILS_GETVALUE (double); |
| break; |
| case (G_TYPE_STRING): |
| g_value_set_string (value, *(gchar **) (option + p->offset)); |
| break; |
| case (G_TYPE_ENUM): |
| g_value_set_enum (value, *(gint *) (option + p->offset)); |
| break; |
| default: |
| ret = FALSE; |
| break; |
| }; |
| } |
| } else { |
| ret = FALSE; |
| } |
| return ret; |
| } |
| |
| |
| gboolean |
| gstsutils_options_set_option (GstsutilsOptionEntry * table, gchar * option, |
| guint id, const GValue * value) |
| { |
| #define GSTSUTILS_SETVALUE(basetype)\ |
| do {\ |
| *(g##basetype *)(option + p->offset) = g_value_get_##basetype (value); \ |
| }while(0) |
| gboolean ret = TRUE; |
| if ((value) && (option)) { |
| GstsutilsOptionEntry *p = gstsutils_options_search_option_by_id (table, id); |
| if (p) { |
| switch (p->gtype) { |
| case (G_TYPE_BOOLEAN): |
| GSTSUTILS_SETVALUE (boolean); |
| break; |
| case (G_TYPE_INT): |
| GSTSUTILS_SETVALUE (int); |
| break; |
| case (G_TYPE_UINT): |
| GSTSUTILS_SETVALUE (uint); |
| break; |
| case (G_TYPE_LONG): |
| GSTSUTILS_SETVALUE (long); |
| break; |
| case (G_TYPE_ULONG): |
| GSTSUTILS_SETVALUE (ulong); |
| break; |
| case (G_TYPE_INT64): |
| GSTSUTILS_SETVALUE (int64); |
| break; |
| case (G_TYPE_UINT64): |
| GSTSUTILS_SETVALUE (uint64); |
| break; |
| case (G_TYPE_DOUBLE): |
| GSTSUTILS_SETVALUE (double); |
| break; |
| case (G_TYPE_STRING): |
| gstsutils_set_value (option, p, g_value_get_string (value)); |
| break; |
| case (G_TYPE_ENUM): |
| *(gint *) (option + p->offset) = g_value_get_enum (value); |
| break; |
| default: |
| ret = FALSE; |
| break; |
| }; |
| } |
| } else { |
| ret = FALSE; |
| } |
| return ret; |
| } |
| |
| |
| void |
| gstsutils_options_load_default (GstsutilsOptionEntry * table, gchar * option) |
| { |
| if ((table) && (option)) { |
| GstsutilsOptionEntry *p = table; |
| while (p->id != -1) { |
| gstsutils_set_value (option, p, p->def); |
| p++; |
| } |
| } |
| } |
| |
| gboolean |
| gstsutils_options_load_from_keyfile (GstsutilsOptionEntry * table, |
| gchar * option, gchar * filename, gchar * group) |
| { |
| GKeyFile *keyfile = NULL; |
| gboolean ret = FALSE; |
| |
| if (filename == NULL) |
| goto bail; |
| |
| if ((option) && (keyfile = g_key_file_new ()) |
| && (g_key_file_load_from_file (keyfile, filename, G_KEY_FILE_NONE, NULL))) { |
| GstsutilsOptionEntry *p = table; |
| |
| while (p->id != -1) { |
| if (g_key_file_has_key (keyfile, group, p->name, NULL)) { |
| gchar *svalue = g_key_file_get_value (keyfile, group, p->name, NULL); |
| gstsutils_set_value (option, p, svalue); |
| if (svalue) { |
| g_free (svalue); |
| } |
| } |
| p++; |
| }; |
| ret = TRUE; |
| } |
| |
| bail: |
| if (keyfile) { |
| g_key_file_free (keyfile); |
| } |
| return ret; |
| } |
| |
| |
| gboolean |
| gstsutils_elementutil_get_int (gchar * filename, gchar * group, |
| gchar * field, gint * value) |
| { |
| gboolean ret = FALSE; |
| GKeyFile *keyfile = NULL; |
| |
| if ((filename) && (field) && (value)) { |
| if ((keyfile = g_key_file_new ()) |
| && (g_key_file_load_from_file (keyfile, filename, G_KEY_FILE_NONE, |
| NULL))) { |
| if (g_key_file_has_key (keyfile, group, field, NULL)) { |
| *value = g_key_file_get_integer (keyfile, group, field, NULL); |
| ret = TRUE; |
| } |
| } |
| |
| } |
| |
| if (keyfile) { |
| g_key_file_free (keyfile); |
| } |
| return ret; |
| } |
| |
| GstsutilsGroup* |
| gstsutils_parse_group(GKeyFile * keyfile, gchar * group_name) |
| { |
| |
| char ** keys = NULL; |
| char ** key = NULL; |
| char * value = NULL; |
| GstsutilsGroup * group_ptr = NULL; |
| GstsutilsData * data = NULL; |
| gsize len = 0; |
| gint group_num = 0; |
| |
| do{ |
| |
| if(group_name == NULL) |
| break; |
| |
| group_ptr = g_new0 (GstsutilsGroup, 1); |
| |
| if(group_ptr == NULL) |
| break; |
| |
| group_ptr->num = 0; |
| |
| keys = g_key_file_get_keys (keyfile, group_name,&len,NULL); |
| |
| if(keys == NULL) |
| break; |
| |
| group_ptr->num = len; |
| |
| group_ptr->data = g_new0 (GstsutilsData *, group_ptr->num); |
| group_ptr->name = g_strdup(group_name); |
| |
| key = keys; |
| |
| while (*key) { |
| |
| data = NULL; |
| value = g_key_file_get_value (keyfile, group_name, *key, NULL); |
| |
| if(value){ |
| data = g_try_malloc(sizeof(GstsutilsData)); |
| |
| if(data){ |
| |
| data->key = g_strdup(*key); |
| data->value = value; |
| group_ptr->data[group_num] = data; |
| group_num ++; |
| } |
| } |
| |
| key ++; |
| |
| }; |
| |
| g_strfreev (keys); |
| }while(0); |
| |
| |
| return group_ptr; |
| } |
| |
| |
| GstsutilsEntry *gstsutils_init_entry (gchar * filename) |
| { |
| |
| GstsutilsEntry *dlentry = NULL; |
| GstsutilsGroup *group_ptr = NULL; |
| |
| GKeyFile * keyfile = NULL; |
| char ** groups = NULL; |
| char ** group_char = NULL; |
| gsize num = 0; |
| gint group_num = 0; |
| |
| |
| do{ |
| |
| |
| keyfile = g_key_file_new(); |
| |
| if(keyfile == NULL || filename == NULL) |
| break; |
| |
| |
| if(!g_key_file_load_from_file(keyfile, filename, G_KEY_FILE_NONE, |
| NULL)) |
| break; |
| |
| dlentry = g_new0 (GstsutilsEntry, 1); |
| |
| if(dlentry == NULL) |
| break; |
| |
| dlentry->num = 0; |
| |
| groups = g_key_file_get_groups(keyfile,&num); |
| if(groups == NULL || num == 0) |
| break; |
| |
| group_char = groups; |
| group_num = num; |
| |
| dlentry->group = g_new0 (GstsutilsGroup *, group_num); |
| |
| group_char = groups; |
| |
| while (*group_char) { |
| group_ptr = NULL; |
| group_ptr = gstsutils_parse_group (keyfile, *group_char); |
| |
| if (group_ptr) { |
| dlentry->group[dlentry->num] = group_ptr; |
| dlentry->num ++; |
| } |
| |
| group_char++; |
| }; |
| |
| g_strfreev (groups); |
| |
| }while(0); |
| |
| if (keyfile) { |
| g_key_file_free (keyfile); |
| } |
| return dlentry; |
| } |
| int gstsutils_get_group_count(GstsutilsEntry * entry) |
| { |
| int num = 0; |
| if(entry) |
| num = entry->num; |
| return num; |
| } |
| gboolean gstsutils_get_group_by_index (GstsutilsEntry * entry,int index,GstsutilsGroup ** group_out) |
| { |
| |
| gboolean found = FALSE; |
| GstsutilsGroup *group=NULL; |
| do{ |
| if(entry == NULL || group_out == NULL) |
| break; |
| if(index > entry->num && index < 1) |
| break; |
| group = entry->group[index-1]; |
| if(group){ |
| *group_out = group; |
| found = TRUE; |
| } |
| }while(0); |
| return found; |
| } |
| int gstsutils_get_data_count_in_group (GstsutilsGroup * group) |
| { |
| int num = 0; |
| if(group) |
| num = group->num; |
| return num; |
| } |
| gchar * gstsutils_get_group_name (GstsutilsGroup * group) |
| { |
| gchar * name = NULL; |
| if(group) |
| name = g_strdup(group->name); |
| return name; |
| } |
| gboolean gstsutils_get_value_by_index(GstsutilsGroup *group,int index, gchar** key_out, gchar**value_out) |
| { |
| gboolean found = FALSE; |
| GstsutilsData *data=NULL; |
| do{ |
| if(group == NULL || key_out == NULL || value_out == NULL) |
| break; |
| if(index > group->num && index < 1) |
| break; |
| data = group->data[index-1]; |
| if(data){ |
| *key_out = g_strdup(data->key); |
| *value_out = g_strdup(data->value); |
| found = TRUE; |
| } |
| }while(0); |
| return found; |
| } |
| gboolean gstsutils_get_value_by_key(GstsutilsGroup *group,gchar * key, gchar**value_out) |
| { |
| gboolean ret = FALSE; |
| GstsutilsData * data = NULL; |
| gchar * value = NULL; |
| gint i = 0; |
| do{ |
| if(group == NULL || key == NULL || value_out == NULL) |
| break; |
| *value_out = NULL; |
| for(i = 0; i < group->num; i++){ |
| data = group->data[i]; |
| if(!data || data->key == NULL || data->value == NULL) |
| continue; |
| if(!strcmp(key,data->key)){ |
| *value_out = g_strdup(data->value); |
| ret = TRUE; |
| break; |
| } |
| } |
| }while(0); |
| return ret; |
| } |
| void gstsutils_deinit_entry (GstsutilsEntry * entry) |
| { |
| GstsutilsGroup *group=NULL; |
| GstsutilsData *data=NULL; |
| gint i = 0; |
| gint j =0; |
| |
| if(entry == NULL || entry->num == 0) |
| return; |
| |
| for(i = 0; i < entry->num; i++){ |
| group = entry->group[i]; |
| |
| if(group == NULL || group->num == 0) |
| break; |
| |
| for(j = 0; j < group->num; j++){ |
| data = group->data[j]; |
| |
| if(data == NULL) |
| break; |
| |
| if(data->key) |
| g_free (data->key); |
| |
| if(data->value) |
| g_free (data->value); |
| |
| g_free (data); |
| } |
| |
| g_free(group->data); |
| g_free(group->name); |
| g_free (group); |
| |
| } |
| g_free(entry->group); |
| g_free(entry); |
| |
| } |
| void gstsutils_load_default_property(gstsutils_property * table,GstObject* dec, |
| const gchar * filename, const gchar * group) |
| { |
| GKeyFile *keyfile = NULL; |
| gboolean ret = FALSE; |
| |
| if (filename == NULL) |
| goto bail; |
| |
| if((keyfile = g_key_file_new ()) |
| && (g_key_file_load_from_file (keyfile, filename, G_KEY_FILE_NONE, NULL))){ |
| gstsutils_property *p = table; |
| |
| while (p->name != NULL) { |
| if (g_key_file_has_key (keyfile, group, p->name, NULL) && p->set_func) { |
| switch (p->gtype) { |
| case G_TYPE_BOOLEAN: |
| { |
| gboolean value; |
| value = g_key_file_get_boolean(keyfile,group,p->name,NULL); |
| p->set_func(dec,(gboolean)value); |
| break; |
| } |
| case G_TYPE_UINT64: |
| { |
| guint64 value; |
| value = g_key_file_get_uint64(keyfile,group,p->name,NULL); |
| p->set_func(dec,(guint64)value); |
| break; |
| } |
| case G_TYPE_INT64: |
| { |
| gint64 value; |
| value = g_key_file_get_int64(keyfile,group,p->name,NULL); |
| p->set_func(dec,(gint64)value); |
| break; |
| } |
| case G_TYPE_INT: |
| { |
| gint value; |
| value = g_key_file_get_integer(keyfile,group,p->name,NULL); |
| p->set_func(dec,(gint)value); |
| break; |
| } |
| case G_TYPE_UINT: |
| { |
| gint value; |
| value = g_key_file_get_integer(keyfile,group,p->name,NULL); |
| p->set_func(dec,(guint)value); |
| break; |
| } |
| case G_TYPE_STRING: |
| { |
| char * value; |
| value = g_key_file_get_string(keyfile,group,p->name,NULL); |
| if(value){ |
| p->set_func(dec,(gchar *)value); |
| g_free(value); |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| p++; |
| |
| }; |
| ret = TRUE; |
| |
| } |
| bail: |
| if (keyfile) { |
| g_key_file_free (keyfile); |
| } |
| return; |
| } |
| |
