surface: added tbm_surface_internal_set/get_damage func

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

diff --git a/src/tbm_surface_queue.c b/src/tbm_surface_queue.c
index 3b89da1..1d8cc99 100644 (file)
--- a/src/tbm_surface_queue.c
+++ b/src/tbm_surface_queue.c
@@ -38,22 +38,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #define DIRTY_QUEUE    2
 #define NODE_LIST      4
 
-#define TBM_QUEUE_DEBUG 0
-
-#ifdef TRACE
-#define TBM_QUEUE_TRACE(fmt, ...)  { if (bTrace&0x1) fprintf(stderr, "[TBM:TRACE(%d)(%s:%d)] " fmt, getpid(), __func__, __LINE__, ##__VA_ARGS__); }
-#else
-#define TBM_QUEUE_TRACE(fmt, ...)
-#endif /* TRACE */
-
-#if TBM_QUEUE_DEBUG
-#define TBM_LOCK() TBM_LOG_D("[LOCK] %s:%d surface:%p\n", __func__, __LINE__, surface_queue)
-#define TBM_UNLOCK() TBM_LOG_D("[UNLOCK] %s:%d surface:%p\n", __func__, __LINE__, surface_queue)
-#else
-#define TBM_LOCK()
-#define TBM_UNLOCK()
-#endif
-
 static tbm_bufmgr g_surf_queue_bufmgr;
 static pthread_mutex_t tbm_surf_queue_lock;
 void _tbm_surface_queue_mutex_unlock(void);
@@ -61,7 +45,8 @@ void _tbm_surface_queue_mutex_unlock(void);
 /* check condition */
 #define TBM_SURF_QUEUE_RETURN_IF_FAIL(cond) {\
        if (!(cond)) {\
-               TBM_LOG_E("'%s' failed.\n", #cond);\
+               TBM_ERR("'%s' failed.\n", #cond);\
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
                _tbm_surf_queue_mutex_unlock();\
                return;\
        } \
@@ -69,7 +54,8 @@ void _tbm_surface_queue_mutex_unlock(void);
 
 #define TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(cond, val) {\
        if (!(cond)) {\
-               TBM_LOG_E("'%s' failed.\n", #cond);\
+               TBM_ERR("'%s' failed.\n", #cond);\
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
                _tbm_surf_queue_mutex_unlock();\
                return val;\
        } \
@@ -162,6 +148,8 @@ struct _tbm_surface_queue {
        struct list_head item_link; /* link of surface queue */
 
        int modes;
+       unsigned int enqueue_sync_count;
+       unsigned int acquire_sync_count;
 };
 
 static bool
@@ -173,7 +161,7 @@ _tbm_surf_queue_mutex_init(void)
                return true;
 
        if (pthread_mutex_init(&tbm_surf_queue_lock, NULL)) {
-               TBM_LOG_E("fail: pthread_mutex_init\n");
+               TBM_ERR("fail: pthread_mutex_init\n");
                return false;
        }
 
@@ -186,7 +174,7 @@ static void
 _tbm_surf_queue_mutex_lock(void)
 {
        if (!_tbm_surf_queue_mutex_init()) {
-               TBM_LOG_E("fail: _tbm_surf_queue_mutex_init\n");
+               TBM_ERR("fail: _tbm_surf_queue_mutex_init\n");
                return;
        }
 
@@ -221,29 +209,29 @@ _tbm_surface_queue_is_valid(tbm_surface_queue_h surface_queue)
        tbm_surface_queue_h old_data = NULL;
 
        if (surface_queue == NULL) {
-               TBM_LOG_E("error: surface_queue is NULL.\n");
+               TBM_ERR("error: surface_queue is NULL.\n");
                return 0;
        }
 
        if (g_surf_queue_bufmgr == NULL) {
-               TBM_LOG_E("error: g_surf_queue_bufmgr is NULL.\n");
+               TBM_ERR("error: g_surf_queue_bufmgr is NULL.\n");
                return 0;
        }
 
        if (LIST_IS_EMPTY(&g_surf_queue_bufmgr->surf_queue_list)) {
-               TBM_LOG_E("error: surf_queue_list is empty\n");
+               TBM_ERR("error: surf_queue_list is empty\n");
                return 0;
        }
 
        LIST_FOR_EACH_ENTRY(old_data, &g_surf_queue_bufmgr->surf_queue_list,
                                item_link) {
                if (old_data == surface_queue) {
-                       TBM_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+                       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
                        return 1;
                }
        }
 
-       TBM_LOG_E("error: Invalid tbm_surface_queue(%p)\n", surface_queue);
+       TBM_ERR("error: Invalid tbm_surface_queue(%p)\n", surface_queue);
 
        return 0;
 }
@@ -360,7 +348,7 @@ _queue_get_node(tbm_surface_queue_h surface_queue, int type,
                }
        }
 
-       TBM_LOG_E("fail to get the queue_node.\n");
+       TBM_ERR("fail to get the queue_node.\n");
 
        return NULL;
 }
@@ -420,7 +408,7 @@ _notify_remove(struct list_head *list,
                }
        }
 
-       TBM_LOG_E("Cannot find notifiy\n");
+       TBM_ERR("Cannot find notifiy\n");
 }
 
 static void
@@ -480,7 +468,7 @@ _trace_remove(struct list_head *list,
                }
        }
 
-       TBM_LOG_E("Cannot find notifiy\n");
+       TBM_ERR("Cannot find notifiy\n");
 }
 
 static void
@@ -645,13 +633,16 @@ tbm_surface_queue_add_destroy_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(destroy_cb,
+                              TBM_ERROR_INVALID_PARAMETER);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_add(&surface_queue->destory_noti, destroy_cb, data);
 
@@ -668,13 +659,14 @@ tbm_surface_queue_remove_destroy_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_remove(&surface_queue->destory_noti, destroy_cb, data);
 
@@ -691,13 +683,16 @@ tbm_surface_queue_add_dequeuable_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(dequeuable_cb,
+                              TBM_ERROR_INVALID_PARAMETER);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_add(&surface_queue->dequeuable_noti, dequeuable_cb, data);
 
@@ -714,13 +709,14 @@ tbm_surface_queue_remove_dequeuable_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_remove(&surface_queue->dequeuable_noti, dequeuable_cb, data);
 
@@ -737,13 +733,16 @@ tbm_surface_queue_add_dequeue_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(dequeue_cb,
+                              TBM_ERROR_INVALID_PARAMETER);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_add(&surface_queue->dequeue_noti, dequeue_cb, data);
 
@@ -760,13 +759,14 @@ tbm_surface_queue_remove_dequeue_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_remove(&surface_queue->dequeue_noti, dequeue_cb, data);
 
@@ -783,13 +783,16 @@ tbm_surface_queue_add_can_dequeue_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(can_dequeue_cb,
+                              TBM_ERROR_INVALID_PARAMETER);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_add(&surface_queue->can_dequeue_noti, can_dequeue_cb, data);
 
@@ -806,13 +809,14 @@ tbm_surface_queue_remove_can_dequeue_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_remove(&surface_queue->can_dequeue_noti, can_dequeue_cb, data);
 
@@ -829,13 +833,16 @@ tbm_surface_queue_add_acquirable_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(acquirable_cb,
+                              TBM_ERROR_INVALID_PARAMETER);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_add(&surface_queue->acquirable_noti, acquirable_cb, data);
 
@@ -852,13 +859,14 @@ tbm_surface_queue_remove_acquirable_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_remove(&surface_queue->acquirable_noti, acquirable_cb, data);
 
@@ -875,13 +883,16 @@ tbm_surface_queue_add_trace_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(trace_cb,
+                              TBM_ERROR_INVALID_PARAMETER);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _trace_add(&surface_queue->trace_noti, trace_cb, data);
 
@@ -898,13 +909,14 @@ tbm_surface_queue_remove_trace_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _trace_remove(&surface_queue->trace_noti, trace_cb, data);
 
@@ -923,13 +935,14 @@ tbm_surface_queue_set_alloc_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        surface_queue->alloc_cb = alloc_cb;
        surface_queue->free_cb = free_cb;
@@ -948,10 +961,11 @@ tbm_surface_queue_get_width(tbm_surface_queue_h surface_queue)
        int width;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue), 0);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        width = surface_queue->width;
 
@@ -966,10 +980,11 @@ tbm_surface_queue_get_height(tbm_surface_queue_h surface_queue)
        int height;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue), 0);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        height = surface_queue->height;
 
@@ -984,10 +999,11 @@ tbm_surface_queue_get_format(tbm_surface_queue_h surface_queue)
        int format;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue), 0);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        format = surface_queue->format;
 
@@ -1002,10 +1018,11 @@ tbm_surface_queue_get_size(tbm_surface_queue_h surface_queue)
        int queue_size;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue), 0);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        queue_size = surface_queue->queue_size;
 
@@ -1020,13 +1037,16 @@ tbm_surface_queue_add_reset_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(reset_cb,
+                              TBM_ERROR_INVALID_PARAMETER);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_add(&surface_queue->reset_noti, reset_cb, data);
 
@@ -1043,13 +1063,14 @@ tbm_surface_queue_remove_reset_cb(
        void *data)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        _notify_remove(&surface_queue->reset_noti, reset_cb, data);
 
@@ -1068,6 +1089,7 @@ tbm_surface_queue_enqueue(tbm_surface_queue_h
        int queue_type;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
@@ -1079,20 +1101,23 @@ tbm_surface_queue_enqueue(tbm_surface_queue_h
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, surface);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, surface);
 
        node = _queue_get_node(surface_queue, 0, surface, &queue_type);
        if (node == NULL || queue_type != NODE_LIST) {
-               TBM_LOG_E("tbm_surface_queue_enqueue::Surface is existed in free_queue or dirty_queue node:%p, type:%d\n",
+               TBM_ERR("tbm_surface_queue_enqueue::Surface is existed in free_queue or dirty_queue node:%p, type:%d\n",
                        node, queue_type);
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
 
-               if (!node)
+               if (!node) {
+                       _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_UNKNOWN_SURFACE);
                        return TBM_SURFACE_QUEUE_ERROR_UNKNOWN_SURFACE;
-               else
+               } else {
+                       _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_ALREADY_EXIST);
                        return TBM_SURFACE_QUEUE_ERROR_ALREADY_EXIST;
+               }
        }
 
        if (surface_queue->impl && surface_queue->impl->enqueue)
@@ -1101,7 +1126,8 @@ tbm_surface_queue_enqueue(tbm_surface_queue_h
                _tbm_surface_queue_enqueue(surface_queue, node, 1);
 
        if (!_queue_get_node(surface_queue, DIRTY_QUEUE, surface, NULL)) {
-               TBM_LOG_E("enqueue surface(%p) but surface isn't present in the dirty_queue\n", surface);
+               TBM_ERR("enqueue surface(%p) but surface isn't present in the dirty_queue\n", surface);
+               _tbm_set_last_result(TBM_SURFACE_ERROR_INVALID_OPERATION);
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
@@ -1110,6 +1136,17 @@ tbm_surface_queue_enqueue(tbm_surface_queue_h
 
        node->type = QUEUE_NODE_TYPE_ENQUEUE;
 
+       if (surface_queue->enqueue_sync_count == 1) {
+               tbm_surface_info_s info;
+               int ret;
+
+               ret = tbm_surface_map(surface, TBM_SURF_OPTION_READ, &info);
+               if (ret == TBM_SURFACE_ERROR_NONE)
+                       tbm_surface_unmap(surface);
+       }
+
+       if (surface_queue->enqueue_sync_count > 0) surface_queue->enqueue_sync_count--;
+
        pthread_mutex_unlock(&surface_queue->lock);
        pthread_cond_signal(&surface_queue->dirty_cond);
 
@@ -1130,6 +1167,7 @@ tbm_surface_queue_cancel_dequeue(tbm_surface_queue_h
        int queue_type;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
@@ -1138,12 +1176,13 @@ tbm_surface_queue_cancel_dequeue(tbm_surface_queue_h
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, surface);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, surface);
 
        node = _queue_get_node(surface_queue, 0, surface, &queue_type);
        if (node == NULL || queue_type != NODE_LIST) {
-               TBM_LOG_E("tbm_surface_queue_cancel_dequeue::Surface is existed in free_queue or dirty_queue node:%p, type:%d\n",
+               TBM_ERR("tbm_surface_queue_cancel_dequeue::Surface is existed in free_queue or dirty_queue node:%p, type:%d\n",
                        node, queue_type);
+               _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE);
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
@@ -1151,7 +1190,7 @@ tbm_surface_queue_cancel_dequeue(tbm_surface_queue_h
        }
 
        if (node->delete_pending) {
-               TBM_QUEUE_TRACE("delete pending tbm_surface_queue(%p) surface(%p)\n", surface_queue, node->surface);
+               TBM_TRACE_SURFACE_QUEUE("delete pending tbm_surface_queue(%p) surface(%p)\n", surface_queue, node->surface);
 
                _queue_delete_node(surface_queue, node);
 
@@ -1165,7 +1204,7 @@ tbm_surface_queue_cancel_dequeue(tbm_surface_queue_h
        }
 
        if (surface_queue->queue_size < surface_queue->num_attached) {
-               TBM_QUEUE_TRACE("deatch tbm_surface_queue(%p) surface(%p)\n", surface_queue, node->surface);
+               TBM_TRACE_SURFACE_QUEUE("deatch tbm_surface_queue(%p) surface(%p)\n", surface_queue, node->surface);
 
                if (surface_queue->impl && surface_queue->impl->need_detach)
                        surface_queue->impl->need_detach(surface_queue, node);
@@ -1187,9 +1226,10 @@ tbm_surface_queue_cancel_dequeue(tbm_surface_queue_h
                _tbm_surface_queue_release(surface_queue, node, 1);
 
        if (_queue_is_empty(&surface_queue->free_queue)) {
+               TBM_ERR("surface_queue->free_queue is empty.\n");
+               _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE);
                pthread_mutex_unlock(&surface_queue->lock);
 
-               TBM_LOG_E("surface_queue->free_queue is empty.\n");
                _tbm_surf_queue_mutex_unlock();
                return TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
        }
@@ -1213,6 +1253,7 @@ tbm_surface_queue_dequeue(tbm_surface_queue_h
        queue_node *node;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
@@ -1228,7 +1269,8 @@ tbm_surface_queue_dequeue(tbm_surface_queue_h
                        surface_queue->impl->need_attach(surface_queue);
 
                if (!_tbm_surface_queue_is_valid(surface_queue)) {
-                       TBM_LOG_E("surface_queue:%p is invalid", surface_queue);
+                       TBM_ERR("surface_queue:%p is invalid", surface_queue);
+                       _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
                        pthread_mutex_unlock(&surface_queue->lock);
                        _tbm_surf_queue_mutex_unlock();
                        return TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
@@ -1241,7 +1283,8 @@ tbm_surface_queue_dequeue(tbm_surface_queue_h
                node = _tbm_surface_queue_dequeue(surface_queue);
 
        if (node == NULL || node->surface == NULL) {
-               TBM_LOG_E("_queue_node_pop_front failed\n");
+               TBM_ERR("_queue_node_pop_front failed\n");
+               _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_EMPTY);
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
@@ -1251,7 +1294,7 @@ tbm_surface_queue_dequeue(tbm_surface_queue_h
        node->type = QUEUE_NODE_TYPE_DEQUEUE;
        *surface = node->surface;
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, *surface);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, *surface);
 
        pthread_mutex_unlock(&surface_queue->lock);
 
@@ -1268,6 +1311,7 @@ int
 tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue), 0);
 
@@ -1281,14 +1325,14 @@ tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait)
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        if (_queue_is_empty(&surface_queue->free_queue)) {
                if (surface_queue->impl && surface_queue->impl->need_attach)
                        surface_queue->impl->need_attach(surface_queue);
 
                if (!_tbm_surface_queue_is_valid(surface_queue)) {
-                       TBM_LOG_E("surface_queue:%p is invalid", surface_queue);
+                       TBM_ERR("surface_queue:%p is invalid", surface_queue);
                        pthread_mutex_unlock(&surface_queue->lock);
                        _tbm_surf_queue_mutex_unlock();
                        return 0;
@@ -1322,6 +1366,7 @@ tbm_surface_queue_release(tbm_surface_queue_h
        int queue_type;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
@@ -1330,24 +1375,27 @@ tbm_surface_queue_release(tbm_surface_queue_h
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, surface);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, surface);
 
        node = _queue_get_node(surface_queue, 0, surface, &queue_type);
        if (node == NULL || queue_type != NODE_LIST) {
-               TBM_LOG_E("tbm_surface_queue_release::Surface is existed in free_queue or dirty_queue node:%p, type:%d\n",
+               TBM_ERR("tbm_surface_queue_release::Surface is existed in free_queue or dirty_queue node:%p, type:%d\n",
                        node, queue_type);
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
 
-               if (!node)
+               if (!node) {
+                       _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_UNKNOWN_SURFACE);
                        return TBM_SURFACE_QUEUE_ERROR_UNKNOWN_SURFACE;
-               else
+               } else {
+                       _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_ALREADY_EXIST);
                        return TBM_SURFACE_QUEUE_ERROR_ALREADY_EXIST;
+               }
        }
 
        if (node->delete_pending) {
-               TBM_QUEUE_TRACE("delete pending tbm_surface_queue(%p) surface(%p)\n", surface_queue, node->surface);
+               TBM_TRACE_SURFACE_QUEUE("delete pending tbm_surface_queue(%p) surface(%p)\n", surface_queue, node->surface);
 
                _queue_delete_node(surface_queue, node);
 
@@ -1361,7 +1409,7 @@ tbm_surface_queue_release(tbm_surface_queue_h
        }
 
        if (surface_queue->queue_size < surface_queue->num_attached) {
-               TBM_QUEUE_TRACE("deatch tbm_surface_queue(%p) surface(%p)\n", surface_queue, node->surface);
+               TBM_TRACE_SURFACE_QUEUE("deatch tbm_surface_queue(%p) surface(%p)\n", surface_queue, node->surface);
 
                if (surface_queue->impl && surface_queue->impl->need_detach)
                        surface_queue->impl->need_detach(surface_queue, node);
@@ -1383,7 +1431,8 @@ tbm_surface_queue_release(tbm_surface_queue_h
                _tbm_surface_queue_release(surface_queue, node, 1);
 
        if (!_queue_get_node(surface_queue, FREE_QUEUE, surface, NULL)) {
-               TBM_LOG_E("release surface(%p) but surface isn't present in the free_queue\n", surface);
+               TBM_ERR("release surface(%p) but surface isn't present in the free_queue\n", surface);
+               _tbm_set_last_result(TBM_SURFACE_ERROR_INVALID_OPERATION);
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
@@ -1412,6 +1461,7 @@ tbm_surface_queue_cancel_acquire(tbm_surface_queue_h
        int queue_type;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
@@ -1420,12 +1470,13 @@ tbm_surface_queue_cancel_acquire(tbm_surface_queue_h
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, surface);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, surface);
 
        node = _queue_get_node(surface_queue, 0, surface, &queue_type);
        if (node == NULL || queue_type != NODE_LIST) {
-               TBM_LOG_E("tbm_surface_queue_cancel_acquire::Surface is existed in free_queue or dirty_queue node:%p, type:%d\n",
+               TBM_ERR("tbm_surface_queue_cancel_acquire::Surface is existed in free_queue or dirty_queue node:%p, type:%d\n",
                        node, queue_type);
+               _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_ALREADY_EXIST);
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
@@ -1438,7 +1489,8 @@ tbm_surface_queue_cancel_acquire(tbm_surface_queue_h
                _tbm_surface_queue_enqueue(surface_queue, node, 1);
 
        if (_queue_is_empty(&surface_queue->dirty_queue)) {
-               TBM_LOG_E("enqueue surface but queue is empty node:%p\n", node);
+               TBM_ERR("enqueue surface but queue is empty node:%p\n", node);
+               _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_UNKNOWN_SURFACE);
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
@@ -1466,6 +1518,7 @@ tbm_surface_queue_acquire(tbm_surface_queue_h
        queue_node *node;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        *surface = NULL;
 
@@ -1482,7 +1535,8 @@ tbm_surface_queue_acquire(tbm_surface_queue_h
                node = _tbm_surface_queue_acquire(surface_queue);
 
        if (node == NULL || node->surface == NULL) {
-               TBM_LOG_E("_queue_node_pop_front failed\n");
+               TBM_ERR("_queue_node_pop_front failed\n");
+               _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_EMPTY);
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
@@ -1493,7 +1547,20 @@ tbm_surface_queue_acquire(tbm_surface_queue_h
 
        *surface = node->surface;
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, *surface);
+       if (surface_queue->acquire_sync_count == 1) {
+               tbm_surface_info_s info;
+               int ret;
+
+               TBM_ERR("start map surface:%p", *surface);
+               ret = tbm_surface_map(*surface, TBM_SURF_OPTION_READ, &info);
+               TBM_ERR("end map surface:%p", *surface);
+               if (ret == TBM_SURFACE_ERROR_NONE)
+                       tbm_surface_unmap(*surface);
+       }
+
+       if (surface_queue->acquire_sync_count > 0) surface_queue->acquire_sync_count--;
+
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p) tbm_surface(%p)\n", surface_queue, *surface);
 
        pthread_mutex_unlock(&surface_queue->lock);
 
@@ -1511,12 +1578,13 @@ int
 tbm_surface_queue_can_acquire(tbm_surface_queue_h surface_queue, int wait)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue), 0);
 
        pthread_mutex_lock(&surface_queue->lock);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        if (!_queue_is_empty(&surface_queue->dirty_queue)) {
                pthread_mutex_unlock(&surface_queue->lock);
@@ -1543,10 +1611,11 @@ tbm_surface_queue_destroy(tbm_surface_queue_h surface_queue)
        queue_node *node = NULL, *tmp;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue));
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        LIST_DEL(&surface_queue->item_link);
 
@@ -1583,11 +1652,12 @@ tbm_surface_queue_reset(tbm_surface_queue_h
        queue_node *node = NULL, *tmp;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        if (width == surface_queue->width && height == surface_queue->height &&
                format == surface_queue->format) {
@@ -1638,6 +1708,7 @@ tbm_surface_queue_error_e
 tbm_surface_queue_notify_reset(tbm_surface_queue_h surface_queue)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
@@ -1650,19 +1721,36 @@ tbm_surface_queue_notify_reset(tbm_surface_queue_h surface_queue)
 }
 
 tbm_surface_queue_error_e
+tbm_surface_queue_notify_dequeuable(tbm_surface_queue_h surface_queue)
+{
+       _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
+
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
+                              TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
+
+       _tbm_surf_queue_mutex_unlock();
+
+       _notify_emit(surface_queue, &surface_queue->dequeuable_noti);
+
+       return TBM_SURFACE_QUEUE_ERROR_NONE;
+}
+
+tbm_surface_queue_error_e
 tbm_surface_queue_set_size(tbm_surface_queue_h
                        surface_queue, int queue_size, int flush)
 {
        queue_node *node = NULL, *tmp;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                                        TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(queue_size > 0,
-                                       TBM_SURFACE_QUEUE_ERROR_INVALID_PARAMETER);
+                                       TBM_ERROR_INVALID_PARAMETER);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        if ((surface_queue->queue_size == queue_size) && !flush) {
                _tbm_surf_queue_mutex_unlock();
@@ -1709,7 +1797,7 @@ tbm_surface_queue_set_size(tbm_surface_queue_h
                        int need_del = surface_queue->queue_size - queue_size;
 
                        LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->free_queue.head, item_link) {
-                               TBM_QUEUE_TRACE("deatch tbm_surface_queue(%p) surface(%p)\n", surface_queue, node->surface);
+                               TBM_TRACE_SURFACE_QUEUE("deatch tbm_surface_queue(%p) surface(%p)\n", surface_queue, node->surface);
 
                                if (surface_queue->impl && surface_queue->impl->need_detach)
                                        surface_queue->impl->need_detach(surface_queue, node);
@@ -1738,11 +1826,12 @@ tbm_surface_queue_free_flush(tbm_surface_queue_h surface_queue)
        queue_node *node = NULL;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        if (surface_queue->num_attached == 0) {
                _tbm_surf_queue_mutex_unlock();
@@ -1774,11 +1863,12 @@ tbm_surface_queue_flush(tbm_surface_queue_h surface_queue)
        queue_node *node = NULL, *tmp;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        if (surface_queue->num_attached == 0) {
                _tbm_surf_queue_mutex_unlock();
@@ -1827,17 +1917,20 @@ tbm_surface_queue_get_surfaces(tbm_surface_queue_h surface_queue,
        queue_node *node = NULL;
 
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(num != NULL,
-                              TBM_SURFACE_QUEUE_ERROR_INVALID_PARAMETER);
+                              TBM_ERROR_INVALID_PARAMETER);
 
        *num = 0;
 
        pthread_mutex_lock(&surface_queue->lock);
 
        LIST_FOR_EACH_ENTRY(node, &surface_queue->list, link) {
+               if (node->delete_pending) continue;
+
                if (surfaces)
                        surfaces[*num] = node->surface;
 
@@ -1856,11 +1949,12 @@ tbm_surface_queue_get_trace_surface_num(
                        tbm_surface_queue_h surface_queue, tbm_surface_queue_trace trace, int *num)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(num != NULL,
-                              TBM_SURFACE_QUEUE_ERROR_INVALID_PARAMETER);
+                              TBM_ERROR_INVALID_PARAMETER);
 
        *num = 0;
 
@@ -1952,23 +2046,30 @@ tbm_surface_queue_h
 tbm_surface_queue_create(int queue_size, int width,
                         int height, int format, int flags)
 {
-       TBM_RETURN_VAL_IF_FAIL(queue_size > 0, NULL);
-       TBM_RETURN_VAL_IF_FAIL(width > 0, NULL);
-       TBM_RETURN_VAL_IF_FAIL(height > 0, NULL);
-       TBM_RETURN_VAL_IF_FAIL(format > 0, NULL);
-
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
+
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(queue_size > 0, NULL);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(width > 0, NULL);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(height > 0, NULL);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(format > 0, NULL);
 
        tbm_surface_queue_h surface_queue = (tbm_surface_queue_h) calloc(1,
                                            sizeof(struct _tbm_surface_queue));
-       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(surface_queue != NULL, NULL);
+       if (!surface_queue) {
+               TBM_ERR("cannot allocate the surface_queue.\n");
+               _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
+               _tbm_surf_queue_mutex_unlock();
+               return NULL;
+       }
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        tbm_queue_default *data = (tbm_queue_default *) calloc(1,
                                  sizeof(tbm_queue_default));
        if (data == NULL) {
-               TBM_LOG_E("cannot allocate the tbm_queue_default.\n");
+               TBM_ERR("cannot allocate the tbm_queue_default.\n");
+               _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
                free(surface_queue);
                _tbm_surf_queue_mutex_unlock();
                return NULL;
@@ -2112,23 +2213,30 @@ tbm_surface_queue_h
 tbm_surface_queue_sequence_create(int queue_size, int width,
                                  int height, int format, int flags)
 {
-       TBM_RETURN_VAL_IF_FAIL(queue_size > 0, NULL);
-       TBM_RETURN_VAL_IF_FAIL(width > 0, NULL);
-       TBM_RETURN_VAL_IF_FAIL(height > 0, NULL);
-       TBM_RETURN_VAL_IF_FAIL(format > 0, NULL);
-
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
+
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(queue_size > 0, NULL);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(width > 0, NULL);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(height > 0, NULL);
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(format > 0, NULL);
 
        tbm_surface_queue_h surface_queue = (tbm_surface_queue_h) calloc(1,
                                            sizeof(struct _tbm_surface_queue));
-       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(surface_queue != NULL, NULL);
+       if (surface_queue == NULL) {
+               TBM_ERR("cannot allocate the surface_queue.\n");
+               _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
+               _tbm_surf_queue_mutex_unlock();
+               return NULL;
+       }
 
-       TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
        tbm_queue_sequence *data = (tbm_queue_sequence *) calloc(1,
                                   sizeof(tbm_queue_sequence));
        if (data == NULL) {
-               TBM_LOG_E("cannot allocate the tbm_queue_sequence.\n");
+               TBM_ERR("cannot allocate the tbm_queue_sequence.\n");
+               _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
                free(surface_queue);
                _tbm_surf_queue_mutex_unlock();
                return NULL;
@@ -2150,6 +2258,7 @@ tbm_surface_queue_set_modes(tbm_surface_queue_h surface_queue,
                                  int modes)
 {
        _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
                               TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
@@ -2167,3 +2276,35 @@ tbm_surface_queue_set_modes(tbm_surface_queue_h surface_queue,
 
        return TBM_SURFACE_QUEUE_ERROR_NONE;
 }
+
+tbm_surface_queue_error_e
+tbm_surface_queue_set_sync_count(tbm_surface_queue_h surface_queue,
+                                 unsigned int sync_count)
+{
+       int dequeue_num, enqueue_num;
+
+       _tbm_surf_queue_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
+
+       TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue),
+                                  TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE);
+
+       pthread_mutex_lock(&surface_queue->lock);
+
+       dequeue_num = _tbm_surface_queue_get_node_count(surface_queue, QUEUE_NODE_TYPE_DEQUEUE);
+       enqueue_num = _tbm_surface_queue_get_node_count(surface_queue, QUEUE_NODE_TYPE_ENQUEUE);
+
+       if (dequeue_num + sync_count == 0)
+               surface_queue->acquire_sync_count = enqueue_num;
+       else
+               surface_queue->enqueue_sync_count = dequeue_num + sync_count;
+
+       TBM_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p) enqueue_sync_count:(%d) acquire_sync_count:(%d)\n",
+                               surface_queue, surface_queue->enqueue_sync_count, surface_queue->acquire_sync_count);
+
+       pthread_mutex_unlock(&surface_queue->lock);
+
+       _tbm_surf_queue_mutex_unlock();
+
+       return TBM_SURFACE_QUEUE_ERROR_NONE;
+}