Move write_lock from attrs to each attribute

[platform/core/multimedia/libmm-common.git] / mm_attrs_private.c

diff --git a/mm_attrs_private.c b/mm_attrs_private.c
index 9c8df67..f239b05 100644 (file)
--- a/mm_attrs_private.c
+++ b/mm_attrs_private.c
@@ -415,6 +415,7 @@ void mmf_attribute_clear(mmf_attribute_t *item)
        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)
@@ -526,19 +527,6 @@ MMHandleType mmf_attrs_new(int count)
 
        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;
-               }
-               return 0;
-       }
-
        return (MMHandleType) attrs;
 }
 
@@ -583,7 +571,6 @@ void mmf_attrs_free(MMHandleType h)
                        free(attrs->items);
                        attrs->items = NULL;
                }
-               pthread_mutex_destroy(&attrs->write_lock);
                free(attrs);
        }
 }
@@ -592,43 +579,48 @@ 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;
 
        for (i = 0; i < count; i++) {
-               mmf_attribute_init(&attrs->items[i],
+               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,
+                       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 = (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,
+                       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");
@@ -645,31 +637,34 @@ int mmf_attrs_commit(MMHandleType h)
        return_val_if_fail(h, -1);
 
        mmf_attrs_t *attrs = (mmf_attrs_t * )h;
+       mmf_attribute_t *item = NULL;
        int i;
        int ret = 0;
 
-       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;
                                }
                        } else {
-                               mmf_attribute_commit(&attrs->items[i]);
+                               mmf_attribute_commit(item);
                        }
                }
-       }
 
-       MM_ATTRS_WRITE_UNLOCK(attrs);
+               MM_ATTR_ITEM_WRITE_UNLOCK(item);
+       }
 
        return ret;
 }
@@ -677,39 +672,43 @@ int mmf_attrs_commit(MMHandleType h)
 int mmf_attrs_commit_err(MMHandleType h, char **err_attr_name)
 {
        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;
 }