queue: emit signal free_cond in queue_notify_dequeuable

[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 0896edc..9fc33a5 100644 (file)
--- a/src/tbm_surface_queue.c
+++ b/src/tbm_surface_queue.c
@@ -46,6 +46,7 @@ void _tbm_surface_queue_mutex_unlock(void);
 #define TBM_SURF_QUEUE_RETURN_IF_FAIL(cond) {\
        if (!(cond)) {\
                TBM_ERR("'%s' failed.\n", #cond);\
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
                _tbm_surf_queue_mutex_unlock();\
                return;\
        } \
@@ -54,6 +55,7 @@ void _tbm_surface_queue_mutex_unlock(void);
 #define TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(cond, val) {\
        if (!(cond)) {\
                TBM_ERR("'%s' failed.\n", #cond);\
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
                _tbm_surf_queue_mutex_unlock();\
                return val;\
        } \
@@ -631,6 +633,7 @@ 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);
@@ -656,6 +659,7 @@ 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);
@@ -679,6 +683,7 @@ 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);
@@ -704,6 +709,7 @@ 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);
@@ -727,6 +733,7 @@ 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);
@@ -752,6 +759,7 @@ 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);
@@ -775,6 +783,7 @@ 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);
@@ -800,6 +809,7 @@ 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);
@@ -823,6 +833,7 @@ 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);
@@ -848,6 +859,7 @@ 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);
@@ -871,6 +883,7 @@ 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);
@@ -896,6 +909,7 @@ 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);
@@ -921,6 +935,7 @@ 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);
@@ -946,6 +961,7 @@ 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);
 
@@ -964,6 +980,7 @@ 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);
 
@@ -982,6 +999,7 @@ 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);
 
@@ -1000,6 +1018,7 @@ 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);
 
@@ -1018,6 +1037,7 @@ 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);
@@ -1043,6 +1063,7 @@ 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);
@@ -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);
@@ -1089,10 +1111,13 @@ tbm_surface_queue_enqueue(tbm_surface_queue_h
 
                _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)
@@ -1102,10 +1127,11 @@ tbm_surface_queue_enqueue(tbm_surface_queue_h
 
        if (!_queue_get_node(surface_queue, DIRTY_QUEUE, surface, NULL)) {
                TBM_ERR("enqueue surface(%p) but surface isn't present in the dirty_queue\n", surface);
+               _tbm_set_last_result(TBM_SURFACE_QUEUE_ERROR_INVALID_SEQUENCE);
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
-               return TBM_SURFACE_ERROR_INVALID_OPERATION;
+               return TBM_SURFACE_QUEUE_ERROR_INVALID_SEQUENCE;
        }
 
        node->type = QUEUE_NODE_TYPE_ENQUEUE;
@@ -1141,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);
@@ -1155,6 +1182,7 @@ tbm_surface_queue_cancel_dequeue(tbm_surface_queue_h
        if (node == NULL || queue_type != NODE_LIST) {
                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();
@@ -1198,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_ERR("surface_queue->free_queue is empty.\n");
                _tbm_surf_queue_mutex_unlock();
                return TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
        }
@@ -1224,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);
@@ -1240,6 +1270,7 @@ tbm_surface_queue_dequeue(tbm_surface_queue_h
 
                if (!_tbm_surface_queue_is_valid(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;
@@ -1253,6 +1284,7 @@ tbm_surface_queue_dequeue(tbm_surface_queue_h
 
        if (node == NULL || node->surface == NULL) {
                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();
@@ -1279,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);
 
@@ -1312,8 +1345,7 @@ tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait)
                return 1;
        }
 
-       if (wait && _tbm_surface_queue_get_node_count(surface_queue,
-                                               QUEUE_NODE_TYPE_ACQUIRE)) {
+       if (wait) {
                _tbm_surf_queue_mutex_unlock();
                pthread_cond_wait(&surface_queue->free_cond, &surface_queue->lock);
                pthread_mutex_unlock(&surface_queue->lock);
@@ -1333,6 +1365,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);
@@ -1351,10 +1384,13 @@ tbm_surface_queue_release(tbm_surface_queue_h
 
                _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) {
@@ -1395,6 +1431,7 @@ tbm_surface_queue_release(tbm_surface_queue_h
 
        if (!_queue_get_node(surface_queue, FREE_QUEUE, surface, NULL)) {
                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();
@@ -1423,6 +1460,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);
@@ -1437,6 +1475,7 @@ tbm_surface_queue_cancel_acquire(tbm_surface_queue_h
        if (node == NULL || queue_type != NODE_LIST) {
                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();
@@ -1450,6 +1489,7 @@ tbm_surface_queue_cancel_acquire(tbm_surface_queue_h
 
        if (_queue_is_empty(&surface_queue->dirty_queue)) {
                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();
@@ -1477,6 +1517,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;
 
@@ -1494,6 +1535,7 @@ tbm_surface_queue_acquire(tbm_surface_queue_h
 
        if (node == NULL || node->surface == NULL) {
                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();
@@ -1535,6 +1577,7 @@ 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);
 
@@ -1567,6 +1610,7 @@ 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));
 
@@ -1607,6 +1651,7 @@ 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);
@@ -1662,6 +1707,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);
@@ -1677,10 +1723,15 @@ 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);
 
+       pthread_mutex_lock(&surface_queue->lock);
+       pthread_mutex_unlock(&surface_queue->lock);
+       pthread_cond_signal(&surface_queue->free_cond);
+
        _tbm_surf_queue_mutex_unlock();
 
        _notify_emit(surface_queue, &surface_queue->dequeuable_noti);
@@ -1695,6 +1746,7 @@ tbm_surface_queue_set_size(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);
@@ -1711,6 +1763,14 @@ tbm_surface_queue_set_size(tbm_surface_queue_h
        pthread_mutex_lock(&surface_queue->lock);
 
        if (flush) {
+               surface_queue->queue_size = queue_size;
+
+               if (surface_queue->num_attached == 0) {
+                       pthread_mutex_unlock(&surface_queue->lock);
+                       _tbm_surf_queue_mutex_unlock();
+                       return TBM_SURFACE_QUEUE_ERROR_NONE;
+               }
+
                if (surface_queue->modes & TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE) {
                        /* Destory surface and Push to free_queue */
                        LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->free_queue.head, item_link)
@@ -1730,7 +1790,6 @@ tbm_surface_queue_set_size(tbm_surface_queue_h
                _queue_init(&surface_queue->free_queue);
 
                surface_queue->num_attached = 0;
-               surface_queue->queue_size = queue_size;
 
                if (surface_queue->impl && surface_queue->impl->reset)
                        surface_queue->impl->reset(surface_queue);
@@ -1777,6 +1836,7 @@ 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);
@@ -1813,6 +1873,7 @@ 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);
@@ -1866,6 +1927,7 @@ 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);
@@ -1897,6 +1959,7 @@ 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);
@@ -1993,16 +2056,22 @@ 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_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
@@ -2010,6 +2079,7 @@ tbm_surface_queue_create(int queue_size, int width,
                                  sizeof(tbm_queue_default));
        if (data == NULL) {
                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;
@@ -2153,16 +2223,22 @@ 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_TRACE_SURFACE_QUEUE("tbm_surface_queue(%p)\n", surface_queue);
 
@@ -2170,6 +2246,7 @@ tbm_surface_queue_sequence_create(int queue_size, int width,
                                   sizeof(tbm_queue_sequence));
        if (data == NULL) {
                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;
@@ -2191,6 +2268,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);
@@ -2216,6 +2294,7 @@ tbm_surface_queue_set_sync_count(tbm_surface_queue_h surface_queue,
        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);