#include "mm_debug.h"
#include "mm_attrs_private.h"
-int mmf_value_init(mmf_value_t *value, int type)
+int mmf_value_init(mmf_value_t *v, int type)
{
- return_val_if_fail(value, -1);
+ return_val_if_fail(v, -1);
return_val_if_fail(MMF_IS_VALUE_TYPE(type), -1);
- memset(value, 0, sizeof(*value));
- value->type = type;
+
+ memset(v, 0, sizeof(*v));
+ v->type = type;
return 0;
}
int mmf_value_copy(mmf_value_t *dest, const mmf_value_t *src)
{
return_val_if_fail(dest && src && src->type == dest->type, -1);
+
switch (src->type) {
case MM_ATTRS_TYPE_INT:
dest->value.i_val = src->value.i_val;
int mmf_value_set_int(mmf_value_t *v, int ival)
{
return_val_if_fail(v && v->type == MMF_VALUE_TYPE_INT, -1);
+
v->value.i_val = ival;
return 0;
}
int mmf_value_get_int(const mmf_value_t *v)
{
return_val_if_fail(v && v->type == MMF_VALUE_TYPE_INT, -1);
+
return v->value.i_val;
}
int mmf_value_set_double(mmf_value_t *v, double dval)
{
return_val_if_fail(v && v->type == MMF_VALUE_TYPE_DOUBLE, -1);
+
v->value.d_val = dval;
return 0;
}
double mmf_value_get_double(mmf_value_t *v)
{
- return_val_if_fail(v->type == MMF_VALUE_TYPE_DOUBLE, -1);
- return v->value.d_val;
+ return_val_if_fail(v->type == MMF_VALUE_TYPE_DOUBLE, -1);
+
+ return v->value.d_val;
}
-int mmf_value_set_string(mmf_value_t *v, const char *sval,int size)
+int mmf_value_set_string(mmf_value_t *v, const char *sval, int size)
{
return_val_if_fail(v && v->type == MMF_VALUE_TYPE_STRING, -1);
+
if (v->value.s_val != NULL) {
free(v->value.s_val);
v->value.s_val = NULL;
v->size = 0;
}
- if (sval){
+ if (sval) {
v->value.s_val = strdup(sval);
v->size = size;
- }
- else{
+ } else {
v->value.s_val = NULL;
v->size = 0;
- }
+ }
return 0;
}
char* mmf_value_get_string(const mmf_value_t *v, int *size)
{
return_val_if_fail(v && v->type == MMF_VALUE_TYPE_STRING, NULL);
- *size=v->size;
+
+ *size = v->size;
return v->value.s_val;
}
-int mmf_value_set_data(mmf_value_t *v, void *data,int size)
+int mmf_value_set_data(mmf_value_t *v, void *data, int size)
{
return_val_if_fail(v && v->type == MMF_VALUE_TYPE_DATA, -1);
+
v->value.p_val = data;
- v->size=size;
+ v->size = size;
return 0;
}
-void* mmf_value_get_data(const mmf_value_t *v,int *size)
+void* mmf_value_get_data(const mmf_value_t *v, int *size)
{
return_val_if_fail(v && v->type == MMF_VALUE_TYPE_DATA, NULL);
- *size=v->size;
+
+ *size = v->size;
return v->value.p_val;
}
-void mmf_value_dump(const mmf_value_t *value)
+void mmf_value_dump(const mmf_value_t *v)
{
- return_if_fail(value);
- switch (value->type) {
+ return_if_fail(v);
+
+ switch (v->type) {
case MMF_VALUE_TYPE_INT:
- //mmf_debug(MMF_DEBUG_LOG, "value[int]: %d\n", value->value.i_val);
+ //mmf_debug(MMF_DEBUG_LOG, "value[int]: %d\n", v->value.i_val);
break;
case MMF_VALUE_TYPE_DOUBLE:
- //mmf_debug(MMF_DEBUG_LOG, "value[double]: %f\n", value->value.d_val);
+ //mmf_debug(MMF_DEBUG_LOG, "value[double]: %f\n", v->value.d_val);
break;
case MMF_VALUE_TYPE_STRING:
- //mmf_debug(MMF_DEBUG_LOG, "value[string]: %s\n", value->value.s_val);
+ //mmf_debug(MMF_DEBUG_LOG, "value[string]: %s\n", v->value.s_val);
break;
case MMF_VALUE_TYPE_DATA:
- //mmf_debug(MMF_DEBUG_LOG, "value[data]: %p\n", value->value.p_val);
+ //mmf_debug(MMF_DEBUG_LOG, "value[data]: %p\n", v->value.p_val);
break;
default:
//mmf_debug(MMF_DEBUG_LOG, "value invalid!!\n");
}
}
-int mmf_value_clear(mmf_value_t *value)
+int mmf_value_clear(mmf_value_t *v)
{
- return_val_if_fail(value, -1);
- if (value->type == MMF_VALUE_TYPE_STRING) {
- if (value->value.s_val) {
- free(value->value.s_val);
- value->value.s_val = NULL;
- value->size = 0;
+ return_val_if_fail(v, -1);
+
+ if (v->type == MMF_VALUE_TYPE_STRING) {
+ if (v->value.s_val) {
+ free(v->value.s_val);
+ v->value.s_val = NULL;
+ v->size = 0;
}
}
return 0;
int mmf_value_spec_init(mmf_value_spec_t *vs, int vs_type)
{
return_val_if_fail(vs, -1);
+
memset(vs, 0, sizeof(*vs));
vs->type = vs_type;
return 0;
int mmf_value_spec_clear(mmf_value_spec_t *vs)
{
return_val_if_fail(vs, -1);
- switch(vs->type) {
+
+ switch (vs->type) {
case MMF_VALUE_SPEC_INT_ARRAY:
if (vs->spec.int_spec.array.array) {
free(vs->spec.int_spec.array.array);
bool mmf_attribute_check_flags(mmf_attribute_t *item, int flags)
{
return_val_if_fail(item, false);
+
return item->flags & flags;
}
bool mmf_attribute_validate_int(mmf_attribute_t *item, int val)
{
- return_val_if_fail(item, false);
- return_val_if_fail(item->value.type == MMF_VALUE_TYPE_INT, false);
-
bool valid = true;
int i = 0;
+ return_val_if_fail(item, false);
+ return_val_if_fail(item->value.type == MMF_VALUE_TYPE_INT, false);
+
switch (item->value_spec.type) {
case MMF_VALUE_SPEC_INT_RANGE:
if (val < item->value_spec.spec.int_spec.range.min ||
val > item->value_spec.spec.int_spec.range.max) {
valid = false;
- //mmf_debug(MMF_DEBUG_LOG, "[mmf_attribute:%s] out of range\n", item->name);
+ debug_error("[mmf_attribute:%s] out of range[min %d, max %d, set %d]",
+ item->name, item->value_spec.spec.int_spec.range.min,
+ item->value_spec.spec.int_spec.range.max, val);
}
break;
case MMF_VALUE_SPEC_INT_ARRAY:
}
}
if (!valid) {
- //mmf_debug(MMF_DEBUG_LOG, "[mmf_attribute:%s] out of array\n", item->name);
+ debug_error("[mmf_attribute:%s] out of array, set %d", item->name, val);
+ for (i = 0; i < item->value_spec.spec.int_spec.array.count; i++) {
+ debug_error("array[index %d] value [%d]",
+ i, item->value_spec.spec.int_spec.array.array[i]);
+ }
}
break;
default:
bool mmf_attribute_validate_double(mmf_attribute_t *item, double val)
{
- return_val_if_fail(item, false);
- return_val_if_fail(item->value.type == MMF_VALUE_TYPE_DOUBLE, false);
-
bool valid = true;
int i = 0;
+ return_val_if_fail(item, false);
+ return_val_if_fail(item->value.type == MMF_VALUE_TYPE_DOUBLE, false);
+
switch (item->value_spec.type) {
case MMF_VALUE_SPEC_DOUBLE_RANGE:
if (val < item->value_spec.spec.double_spec.range.min ||
void mmf_attribute_clear(mmf_attribute_t *item)
{
assert(item);
+
if (item->name) {
free(item->name);
item->name = NULL;
mmf_value_clear(&item->tmpval);
mmf_value_clear(&item->value);
mmf_value_spec_clear(&item->value_spec);
+ pthread_mutex_destroy(&item->write_lock);
}
bool mmf_attribute_is_modified(mmf_attribute_t *item)
{
return_val_if_fail(item, false);
+
return (item->flags & MM_ATTRS_FLAG_MODIFIED);
}
void mmf_attribute_set_modified(mmf_attribute_t *item)
{
return_if_fail(item);
+
if (!(item->flags & MM_ATTRS_FLAG_MODIFIED)) {
mmf_value_copy(&item->tmpval, &item->value);
item->flags |= MM_ATTRS_FLAG_MODIFIED;
void mmf_attribute_set_readonly(mmf_attribute_t *item)
{
return_if_fail(item);
+
if (item->flags & MM_ATTRS_FLAG_WRITABLE)
item->flags -= MM_ATTRS_FLAG_WRITABLE;
}
void mmf_attribute_set_disabled(mmf_attribute_t *item)
{
return_if_fail(item);
+
if (item->flags & MM_ATTRS_FLAG_WRITABLE)
item->flags -= MM_ATTRS_FLAG_WRITABLE;
if (item->flags & MM_ATTRS_FLAG_READABLE)
void mmf_attribute_commit(mmf_attribute_t *item)
{
return_if_fail(item);
+
if (item->flags & MM_ATTRS_FLAG_MODIFIED) {
mmf_value_copy(&item->value, &item->tmpval);
mmf_value_clear(&item->tmpval);
int mmf_attribute_set_int(mmf_attribute_t *item, int val)
{
return_val_if_fail(item, -1);
+
if (mmf_value_set_int(&item->tmpval, val) == 0) {
item->flags |= MM_ATTRS_FLAG_MODIFIED;
return 0;
int mmf_attribute_set_double(mmf_attribute_t *item, double val)
{
return_val_if_fail(item, -1);
+
if (mmf_value_set_double(&item->tmpval, val) == 0) {
item->flags |= MM_ATTRS_FLAG_MODIFIED;
return 0;
{
return_val_if_fail(item, -1);
- if (mmf_value_set_string(&item->tmpval, string,size) == 0) {
- if (string)
- item->flags |= MM_ATTRS_FLAG_MODIFIED;
-
+ if (mmf_value_set_string(&item->tmpval, string, size) == 0) {
+ item->flags |= MM_ATTRS_FLAG_MODIFIED;
return 0;
}
return -1;
{
return_val_if_fail(item, -1);
- if (mmf_value_set_data(&item->tmpval, data,size) == 0) {
+ if (mmf_value_set_data(&item->tmpval, data, size) == 0) {
item->flags |= MM_ATTRS_FLAG_MODIFIED;
return 0;
}
MMHandleType mmf_attrs_new(int count)
{
- return_val_if_fail(count > 0, 0);
mmf_attrs_t *attrs;
- attrs = (mmf_attrs_t *) malloc (sizeof(mmf_attrs_t));
+ return_val_if_fail(count > 0, 0);
+
+ attrs = (mmf_attrs_t *) malloc(sizeof(mmf_attrs_t));
if (attrs == NULL) {
debug_error("malloc failed");
return 0;
}
attrs->count = count;
- attrs->items = (mmf_attribute_t *) malloc (sizeof(mmf_attribute_t) * count);
- if(attrs->items == NULL) {
- debug_error("Failed to malloc for attrs->items.");
- free(attrs);
- attrs=NULL;
- return 0;
- }
-
- memset(attrs->items, 0, sizeof(mmf_attribute_t) * count);
-
- if (pthread_mutex_init(&attrs->write_lock, NULL) != 0) {
- //mmf_debug(MMF_DEBUG_ERROR, "mutex init failed");
- if (attrs) {
- if (attrs->items) {
- free(attrs->items);
- attrs->items = NULL;
- }
- free(attrs);
- attrs=NULL;
- }
+ attrs->items = (mmf_attribute_t *) malloc(sizeof(mmf_attribute_t) * count);
+ if (attrs->items == NULL) {
+ debug_error("Failed to malloc for attrs->items.");
+ free(attrs);
+ attrs = NULL;
return 0;
}
+ memset(attrs->items, 0, sizeof(mmf_attribute_t) * count);
+
return (MMHandleType) attrs;
}
MMHandleType mmf_attrs_new_from_data(const char *name,
- mmf_attrs_construct_info_t *info,
- int count,
- mmf_attrs_commit_func_t commit_func,
- void *commit_param)
+ mmf_attrs_construct_info_t *info,
+ int count,
+ mmf_attrs_commit_func_t commit_func,
+ void *commit_param)
{
- return_val_if_fail(info && count > 0, 0);
MMHandleType h;
mmf_attrs_t *attrs;
+ return_val_if_fail(info && count > 0, NULL);
+
h = mmf_attrs_new(count);
- if(!h) {
- return 0;
+ if (!h) {
+ return NULL;
}
mmf_attrs_init(h, info, count);
attrs = (mmf_attrs_t *) h;
void mmf_attrs_free(MMHandleType h)
{
- return_if_fail(h);
mmf_attrs_t *attrs = (mmf_attrs_t *) h;
- if (attrs) {
- if (attrs->name) {
- free(attrs->name);
- attrs->name = NULL;
- }
- if (attrs->items) {
- int i;
- for (i = 0; i < attrs->count; i++) {
- mmf_attribute_clear(&attrs->items[i]);
- }
- free(attrs->items);
- attrs->items = NULL;
+
+ return_if_fail(h);
+
+ if (attrs->name) {
+ free(attrs->name);
+ attrs->name = NULL;
+ }
+
+ if (attrs->items) {
+ int i;
+ for (i = 0; i < attrs->count; i++) {
+ mmf_attribute_clear(&attrs->items[i]);
}
- pthread_mutex_destroy(&attrs->write_lock);
- free(attrs);
+ free(attrs->items);
+ attrs->items = NULL;
}
+
+ free(attrs);
}
int mmf_attrs_init(MMHandleType h, mmf_attrs_construct_info_t *info, int count)
{
- return_val_if_fail(h && info && count > 0, -1);
mmf_attrs_t *attrs = (mmf_attrs_t *) h;
+ mmf_attribute_t *item = NULL;
int i;
int size = 0;
+ return_val_if_fail(h && info && count > 0, -1);
+
for (i = 0; i < count; i++) {
- mmf_attribute_init(&attrs->items[i],
- info[i].name,
- info[i].value_type,
- info[i].flags);
+ item = &attrs->items[i];
+
+ pthread_mutex_init(&item->write_lock, NULL);
+
+ mmf_attribute_init(item,
+ info[i].name,
+ info[i].value_type,
+ info[i].flags);
switch (info[i].value_type) {
case MMF_VALUE_TYPE_INT:
- assert(attrs->items[i].value.value.i_val == 0);
- mmf_value_set_int(&attrs->items[i].value,
- (int)info[i].default_value);
+ assert(item->value.value.i_val == 0);
+ mmf_value_set_int(&item->value,
+ (intptr_t)info[i].default_value);
break;
case MMF_VALUE_TYPE_DOUBLE:
{
- int i_val = (int)info[i].default_value;
+ int i_val = (intptr_t)info[i].default_value;
double d_val = (double) i_val;
- assert(attrs->items[i].value.value.d_val == 0);
- mmf_value_set_double(&attrs->items[i].value, d_val);
+ assert(item->value.value.d_val == 0);
+ mmf_value_set_double(&item->value, d_val);
break;
}
case MMF_VALUE_TYPE_STRING:
- assert(attrs->items[i].value.value.s_val == NULL);
+ assert(item->value.value.s_val == NULL);
if (info[i].default_value) {
size = strlen(info[i].default_value)+1;
}
- mmf_value_set_string(&attrs->items[i].value,
- (const char *)info[i].default_value,size);
+ mmf_value_set_string(&item->value,
+ (const char *)info[i].default_value, size);
break;
case MMF_VALUE_TYPE_DATA:
- assert(attrs->items[i].value.value.p_val == NULL);
+ assert(item->value.value.p_val == NULL);
if (info[i].default_value) {
size = sizeof(info[i].default_value)+1;
}
- mmf_value_set_data(&attrs->items[i].value, info[i].default_value,size);
+ mmf_value_set_data(&item->value, info[i].default_value, size);
break;
default:
//mmf_debug(MMF_DEBUG_LOG, "ERROR: Invalid MMF_VALUE_TYPE\n");
int mmf_attrs_commit(MMHandleType h)
{
- return_val_if_fail(h, -1);
-
- mmf_attrs_t *attrs = (mmf_attrs_t * )h;
+ mmf_attrs_t *attrs = (mmf_attrs_t *)h;
+ mmf_attribute_t *item = NULL;
int i;
int ret = 0;
- MM_ATTRS_WRITE_LOCK(attrs);
+ return_val_if_fail(h, -1);
for (i = 0; i < attrs->count; ++i) {
- if (mmf_attribute_is_modified(&attrs->items[i])) {
+ item = &attrs->items[i];
+
+ MM_ATTR_ITEM_WRITE_LOCK(item);
+
+ if (mmf_attribute_is_modified(item)) {
if (attrs->commit_func) {
- if (attrs->commit_func(i, attrs->items[i].name,
- &attrs->items[i].tmpval,
+ if (attrs->commit_func(i, item->name,
+ &item->tmpval,
attrs->commit_param)) {
- mmf_attribute_commit(&attrs->items[i]);
+ mmf_attribute_commit(item);
} else {
/* without this, there is no way to solve modify when commit_func failed. */
- if (attrs->items[i].flags & MM_ATTRS_FLAG_MODIFIED)
- attrs->items[i].flags ^= MM_ATTRS_FLAG_MODIFIED;
+ if (item->flags & MM_ATTRS_FLAG_MODIFIED)
+ item->flags ^= MM_ATTRS_FLAG_MODIFIED;
ret = -1;
}
} else {
- mmf_attribute_commit(&attrs->items[i]);
+ mmf_attribute_commit(item);
}
}
- }
- MM_ATTRS_WRITE_UNLOCK(attrs);
+ MM_ATTR_ITEM_WRITE_UNLOCK(item);
+ }
return ret;
}
int mmf_attrs_commit_err(MMHandleType h, char **err_attr_name)
{
- mmf_attrs_t *attrs = (mmf_attrs_t * )h;
+ mmf_attrs_t *attrs = (mmf_attrs_t *)h;
+ mmf_attribute_t *item = NULL;
int i;
int ret = 0;
return_val_if_fail(h, -1);
- MM_ATTRS_WRITE_LOCK(attrs);
-
for (i = 0; i < attrs->count; ++i) {
- if (mmf_attribute_is_modified(&attrs->items[i])) {
+ item = &attrs->items[i];
+
+ MM_ATTR_ITEM_WRITE_LOCK(item);
+
+ if (mmf_attribute_is_modified(item)) {
if (attrs->commit_func) {
- if (attrs->commit_func(i, attrs->items[i].name,
- &attrs->items[i].tmpval,
+ if (attrs->commit_func(i, item->name,
+ &item->tmpval,
attrs->commit_param)) {
- mmf_attribute_commit(&attrs->items[i]);
+ mmf_attribute_commit(item);
} else {
/* without this, there is no way to solve modify when commit_func failed. */
- if (attrs->items[i].flags & MM_ATTRS_FLAG_MODIFIED)
- attrs->items[i].flags ^= MM_ATTRS_FLAG_MODIFIED;
+ if (item->flags & MM_ATTRS_FLAG_MODIFIED)
+ item->flags ^= MM_ATTRS_FLAG_MODIFIED;
ret = -1;
/* Set Error information */
if (err_attr_name)
- *err_attr_name = strdup(attrs->items[i].name);
+ *err_attr_name = strdup(item->name);
+ MM_ATTR_ITEM_WRITE_UNLOCK(item);
break;
}
} else {
- mmf_attribute_commit(&attrs->items[i]);
+ mmf_attribute_commit(item);
}
}
- }
- MM_ATTRS_WRITE_UNLOCK(attrs);
+ MM_ATTR_ITEM_WRITE_UNLOCK(item);
+ }
return ret;
}
int mmf_attrs_set_valid_type(MMHandleType h, int idx, int v_type)
{
- return_val_if_fail(h, -1);
- return_val_if_fail(idx>=0, -1);
mmf_attrs_t *attrs = (mmf_attrs_t *) h;
+
+ return_val_if_fail(h, -1);
+ return_val_if_fail(idx >= 0, -1);
+
return mmf_value_spec_init(&attrs->items[idx].value_spec, v_type);
}
int mmf_attrs_set_valid_range(MMHandleType h, int idx, int min, int max, int dval)
{
- return_val_if_fail(h, -1);
- return_val_if_fail(idx>=0, -1);
mmf_attrs_t *attrs = (mmf_attrs_t *) h;
+
+ return_val_if_fail(h, -1);
+ return_val_if_fail(idx >= 0, -1);
+
mmf_value_spec_clear(&attrs->items[idx].value_spec);
assert(attrs->items[idx].value_spec.type == MMF_VALUE_SPEC_INT_RANGE);
return mmf_value_spec_set_int_range(&attrs->items[idx].value_spec, min, max, dval);
int mmf_attrs_set_valid_array(MMHandleType h, int idx, const int *array, int count, int dval)
{
- return_val_if_fail(h, -1);
- return_val_if_fail(idx>=0, -1);
mmf_attrs_t *attrs = (mmf_attrs_t *) h;
+
+ return_val_if_fail(h, -1);
+ return_val_if_fail(idx >= 0, -1);
+
mmf_value_spec_clear(&attrs->items[idx].value_spec);
assert(attrs->items[idx].value_spec.type == MMF_VALUE_SPEC_INT_ARRAY);
return mmf_value_spec_set_int_array(&attrs->items[idx].value_spec, array, count, dval);
int mmf_attrs_set_valid_double_range(MMHandleType h, int idx, double min, double max, double dval)
{
- return_val_if_fail(h, -1);
- return_val_if_fail(idx>=0, -1);
mmf_attrs_t *attrs = (mmf_attrs_t *) h;
+
+ return_val_if_fail(h, -1);
+ return_val_if_fail(idx >= 0, -1);
+
mmf_value_spec_clear(&attrs->items[idx].value_spec);
assert(attrs->items[idx].value_spec.type == MMF_VALUE_SPEC_DOUBLE_RANGE);
- return mmf_value_spec_set_double_range(&attrs->items[idx].value_spec, min, max, dval);
+
+ if (mmf_value_spec_set_double_range(&attrs->items[idx].value_spec, min, max, dval) != 0)
+ return -1;
+
+ return mmf_value_set_double(&attrs->items[idx].value, dval);
}
int mmf_attrs_set_valid_double_array(MMHandleType h, int idx, const double *array, int count, double dval)
{
- return_val_if_fail(h, -1);
- return_val_if_fail(idx>=0, -1);
mmf_attrs_t *attrs = (mmf_attrs_t *) h;
+
+ return_val_if_fail(h, -1);
+ return_val_if_fail(idx >= 0, -1);
+
mmf_value_spec_clear(&attrs->items[idx].value_spec);
assert(attrs->items[idx].value_spec.type == MMF_VALUE_SPEC_DOUBLE_ARRAY);
- return mmf_value_spec_set_double_array(&attrs->items[idx].value_spec, array, count, dval);
+
+ if (mmf_value_spec_set_double_array(&attrs->items[idx].value_spec, array, count, dval) != 0)
+ return -1;
+
+ return mmf_value_set_double(&attrs->items[idx].value, dval);
}
projects / platform / core / multimedia / libmm-common.git / blobdiff