surface: added tbm_surface_internal_set/get_damage func

[platform/core/uifw/libtbm.git] / src / tbm_bufmgr.c

diff --git a/src/tbm_bufmgr.c b/src/tbm_bufmgr.c
index 8988299..962fbb6 100644 (file)
--- a/src/tbm_bufmgr.c
+++ b/src/tbm_bufmgr.c
@@ -76,6 +76,7 @@ static void _tbm_bufmgr_mutex_unlock(void);
 #define TBM_BUFMGR_RETURN_IF_FAIL(cond) {\
        if (!(cond)) {\
                TBM_ERR("'%s' failed.\n", #cond);\
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
                _tbm_bufmgr_mutex_unlock();\
                return;\
        } \
@@ -84,6 +85,7 @@ static void _tbm_bufmgr_mutex_unlock(void);
 #define TBM_BUFMGR_RETURN_VAL_IF_FAIL(cond, val) {\
        if (!(cond)) {\
                TBM_ERR("'%s' failed.\n", #cond);\
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
                _tbm_bufmgr_mutex_unlock();\
                return val;\
        } \
@@ -517,6 +519,8 @@ _tbm_bufmgr_init(int fd, int server)
 
        pthread_mutex_lock(&gLock);
 
+       _tbm_set_last_result(TBM_ERROR_NONE);
+
        if (fd >= 0) {
                TBM_WRN("!!!!!WARNING:: The tbm_bufmgr_init DOSE NOT use argument fd ANYMORE.\n");
                TBM_WRN("!!!!!WARNING:: IT WILL BE CHANGED like tbm_bufmgr_init(int fd) --> tbm_bufmgr_init(void).\n");
@@ -537,6 +541,7 @@ _tbm_bufmgr_init(int fd, int server)
        gBufMgr = calloc(1, sizeof(struct _tbm_bufmgr));
        if (!gBufMgr) {
                TBM_ERR("error: fail to alloc bufmgr fd(%d)\n", fd);
+               _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
                pthread_mutex_unlock(&gLock);
                return NULL;
        }
@@ -552,6 +557,7 @@ _tbm_bufmgr_init(int fd, int server)
        /* load bufmgr priv from env */
        if (!_tbm_load_module(gBufMgr, gBufMgr->fd)) {
                TBM_ERR("error : Fail to load bufmgr backend\n");
+               _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                free(gBufMgr);
                gBufMgr = NULL;
                pthread_mutex_unlock(&gLock);
@@ -618,6 +624,7 @@ tbm_bufmgr_deinit(tbm_bufmgr bufmgr)
 
        _tbm_bufmgr_mutex_lock();
        pthread_mutex_lock(&gLock);
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        if (!gBufMgr) {
                TBM_ERR("gBufmgr already destroy: bufmgr:%p\n", bufmgr);
@@ -691,6 +698,7 @@ tbm_bufmgr_get_capability(tbm_bufmgr bufmgr)
        unsigned int capabilities = TBM_BUFMGR_CAPABILITY_NONE;
 
        _tbm_bufmgr_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), TBM_BUFMGR_CAPABILITY_NONE);
        TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, TBM_BUFMGR_CAPABILITY_NONE);
@@ -711,11 +719,15 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr)
        char *str;
        int len = 1024*4;
        int c = 0;
+       int size;
+       tbm_error_e error;
 
        pthread_mutex_lock(&gLock);
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        if (!TBM_BUFMGR_IS_VALID(bufmgr) || (bufmgr != gBufMgr)) {
                TBM_ERR("invalid bufmgr\n");
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
                pthread_mutex_unlock(&gLock);
                return NULL;
        }
@@ -723,6 +735,7 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr)
        str = malloc(len);
        if (!str) {
                TBM_ERR("Fail to allocate the string.\n");
+               _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
                pthread_mutex_unlock(&gLock);
                return NULL;
        }
@@ -795,10 +808,16 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr)
                        TBM_SNRPRINTF(str, len, c, "%s\n", data);
 
                        for (i = 0; i < surf->num_bos; i++) {
+                               if (bufmgr->backend_module_data) {
+                                       size = bufmgr->bo_func->bo_get_size(surf->bos[i]->bo_data, &error);
+                                       if (error != TBM_ERROR_NONE)
+                                               TBM_WRN("fail to get the size of bo.");
+                               } else
+                                       size = bufmgr->backend->bo_size(surf->bos[i]);
                                TBM_SNRPRINTF(str, len, c, " bo:%-12p  %-26d%-10d\n",
                                          surf->bos[i],
                                          surf->bos[i]->ref_cnt,
-                                         bufmgr->backend->bo_size(surf->bos[i]) / 1024);
+                                         size / 1024);
                        }
                }
        } else
@@ -812,18 +831,30 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr)
        if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
                int bo_cnt = 0;
                tbm_bo bo = NULL;
+               tbm_key key = 0;
 
                LIST_FOR_EACH_ENTRY(bo, &bufmgr->bo_list, item_link) {
+                       if (bufmgr->backend_module_data) {
+                               size = bufmgr->bo_func->bo_get_size(bo->bo_data, &error);
+                               if (error != TBM_ERROR_NONE)
+                                       TBM_WRN("fail to get the size of bo.");
+                               key = bufmgr->bo_func->bo_export_key(bo->bo_data, &error);
+                               if (error != TBM_ERROR_NONE)
+                                       TBM_WRN("fail to get the tdm_key of bo.");
+                       } else {
+                               size = bufmgr->backend->bo_size(bo);
+                               key = bufmgr->backend->bo_export(bo);
+                       }
                        TBM_SNRPRINTF(str, len, c, "%-4d%-11p   %-4d  %-6d     %-5d     %-4u    %-3d  %-11p  %-4d\n",
                                  ++bo_cnt,
                                  bo,
                                  bo->ref_cnt,
-                                 bufmgr->backend->bo_size(bo) / 1024,
+                                 size / 1024,
                                  bo->lock_cnt,
                                  bo->map_cnt,
                                  bo->flags,
                                  bo->surface,
-                                 bufmgr->backend->bo_export(bo));
+                                 key);
                }
        } else
                TBM_SNRPRINTF(str, len, c, "no tbm_bos.\n");
@@ -851,6 +882,7 @@ void
 tbm_bufmgr_debug_trace(tbm_bufmgr bufmgr, int onoff)
 {
        _tbm_bufmgr_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BUFMGR_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr));
        TBM_BUFMGR_RETURN_IF_FAIL(bufmgr == gBufMgr);
@@ -867,6 +899,7 @@ void
 tbm_bufmgr_debug_set_trace_mask(tbm_bufmgr bufmgr, tbm_bufmgr_debug_trace_mask mask, int set)
 {
        _tbm_bufmgr_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BUFMGR_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr));
        TBM_BUFMGR_RETURN_IF_FAIL(bufmgr == gBufMgr);
@@ -906,6 +939,7 @@ void
 tbm_bufmgr_debug_dump_set_scale(double scale)
 {
        pthread_mutex_lock(&gLock);
+       _tbm_set_last_result(TBM_ERROR_NONE);
        scale_factor = scale;
        pthread_mutex_unlock(&gLock);
 }
@@ -913,13 +947,24 @@ tbm_bufmgr_debug_dump_set_scale(double scale)
 int
 tbm_bufmgr_debug_get_ref_count(void)
 {
-       return (gBufMgr) ? gBufMgr->ref_count : 0;
+       int refcnt;
+
+       pthread_mutex_lock(&gLock);
+
+       _tbm_set_last_result(TBM_ERROR_NONE);
+
+       refcnt = (gBufMgr) ? gBufMgr->ref_count : 0;
+
+       pthread_mutex_unlock(&gLock);
+
+       return refcnt;
 }
 
 int
 tbm_bufmgr_debug_queue_dump(char *path, int count, int onoff)
 {
        pthread_mutex_lock(&gLock);
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        if (onoff == 0) {
                TBM_DBG("count=%d onoff=%d\n", count, onoff);
@@ -948,6 +993,7 @@ tbm_bufmgr_debug_queue_dump(char *path, int count, int onoff)
        }
 
        pthread_mutex_unlock(&gLock);
+
        return 1;
 }
 
@@ -957,16 +1003,22 @@ tbm_bufmgr_debug_dump_all(char *path)
        int w, h, count = 0;
        tbm_surface_h surface = NULL;
 
-       TBM_RETURN_VAL_IF_FAIL(path != NULL, 0);
-       TBM_DBG("path=%s\n", path);
-
        pthread_mutex_lock(&gLock);
+       _tbm_set_last_result(TBM_ERROR_NONE);
+
+       if (!path) {
+               TBM_ERR("path is null.\n");
+               pthread_mutex_unlock(&gLock);
+               return 0;
+       }
+
+       TBM_DBG("path=%s\n", path);
 
        count = _tbm_util_get_max_surface_size(&w, &h);
        if (count == 0) {
                TBM_ERR("No tbm_surface.\n");
                pthread_mutex_unlock(&gLock);
-               return 1;
+               return 0;
        }
 
        tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor);
@@ -993,24 +1045,48 @@ int
 tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *native_display)
 {
        int ret;
+       tbm_error_e error;
 
        _tbm_bufmgr_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
 
-       if (!bufmgr->backend->bufmgr_bind_native_display) {
-               TBM_WRN("skip: tbm_bufmgr(%p) native_display(%p)\n",
-                               bufmgr, native_display);
-               _tbm_bufmgr_mutex_unlock();
-               return 1;
-       }
+       if (bufmgr->backend_module_data) {
+               if (!bufmgr->bufmgr_func->bufmgr_bind_native_display) {
+                       TBM_WRN("skip: tbm_bufmgr(%p) native_display(%p)\n",
+                                       bufmgr, native_display);
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+                       _tbm_bufmgr_mutex_unlock();
+                       return 1;
+               }
 
-       ret = bufmgr->backend->bufmgr_bind_native_display(bufmgr, native_display);
-       if (!ret) {
-               TBM_ERR("error: tbm_bufmgr(%p) native_display(%p)\n",
-                               bufmgr, native_display);
-               _tbm_bufmgr_mutex_unlock();
-               return 0;
+               error = bufmgr->bufmgr_func->bufmgr_bind_native_display(bufmgr->bufmgr_data, (tbm_native_display *)native_display);
+               if (error != TBM_ERROR_NONE) {
+                       TBM_ERR("error: tbm_bufmgr(%p) native_display(%p) error(%d)\n",
+                                       bufmgr, native_display, error);
+                       _tbm_set_last_result(error);
+                       _tbm_bufmgr_mutex_unlock();
+                       return 0;
+               }
+               ret = 1;
+       } else {
+               if (!bufmgr->backend->bufmgr_bind_native_display) {
+                       TBM_WRN("skip: tbm_bufmgr(%p) native_display(%p)\n",
+                                       bufmgr, native_display);
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+                       _tbm_bufmgr_mutex_unlock();
+                       return 1;
+               }
+
+               ret = bufmgr->backend->bufmgr_bind_native_display(bufmgr, native_display);
+               if (!ret) {
+                       TBM_ERR("error: tbm_bufmgr(%p) native_display(%p)\n",
+                                       bufmgr, native_display);
+                       _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
+                       _tbm_bufmgr_mutex_unlock();
+                       return 0;
+               }
        }
 
        TBM_INFO("tbm_bufmgr(%p) native_display(%p)\n", bufmgr, native_display);
@@ -1033,13 +1109,20 @@ tbm_bufmgr_server_init(void)
 int
 tbm_bufmgr_set_bo_lock_type(tbm_bufmgr bufmgr, tbm_bufmgr_bo_lock_type bo_lock_type)
 {
+       _tbm_bufmgr_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
+
        TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
        TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, 0);
 
+       pthread_mutex_lock(&gLock);
        gBufMgr->bo_lock_type = bo_lock_type;
+       pthread_mutex_unlock(&gLock);
 
        TBM_INFO("The bo_lock_type of the bo is %d\n", bo_lock_type);
 
+       _tbm_bufmgr_mutex_unlock();
+
        return 1;
 }