tbm_surface_queue: called need_attach when queue_dequeue

[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 277fda5..1dadcb0 100644 (file)
--- a/src/tbm_surface_queue.c
+++ b/src/tbm_surface_queue.c
@@ -171,7 +171,7 @@ _tbm_surf_queue_mutex_init(void)
                return true;
 
        if (pthread_mutex_init(&tbm_surf_queue_lock, NULL)) {
-               TBM_LOG_E("fail: tbm_surf_queue mutex init\n");
+               TBM_LOG_E("fail: pthread_mutex_init\n");
                return false;
        }
 
@@ -183,8 +183,10 @@ _tbm_surf_queue_mutex_init(void)
 static void
 _tbm_surf_queue_mutex_lock(void)
 {
-       if (!_tbm_surf_queue_mutex_init())
+       if (!_tbm_surf_queue_mutex_init()) {
+               TBM_LOG_E("fail: _tbm_surf_queue_mutex_init\n");
                return;
+       }
 
        pthread_mutex_lock(&tbm_surf_queue_lock);
 }
@@ -216,13 +218,18 @@ _tbm_surface_queue_is_valid(tbm_surface_queue_h surface_queue)
 {
        tbm_surface_queue_h old_data = NULL;
 
-       if (surface_queue == NULL || g_surf_queue_bufmgr == NULL) {
-               TBM_TRACE("error: surface_queue is NULL or not initialized\n");
+       if (surface_queue == NULL) {
+               TBM_LOG_E("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");
                return 0;
        }
 
        if (LIST_IS_EMPTY(&g_surf_queue_bufmgr->surf_queue_list)) {
-               TBM_TRACE("error: surf_queue_list is empty\n");
+               TBM_LOG_E("error: surf_queue_list is empty\n");
                return 0;
        }
 
@@ -234,7 +241,8 @@ _tbm_surface_queue_is_valid(tbm_surface_queue_h surface_queue)
                }
        }
 
-       TBM_TRACE("error: Invalid tbm_surface_queue(%p)\n", surface_queue);
+       TBM_LOG_E("error: Invalid tbm_surface_queue(%p)\n", surface_queue);
+
        return 0;
 }
 
@@ -284,9 +292,12 @@ _queue_node_pop_front(queue *queue)
 {
        queue_node *node;
 
+       if (!queue->head.next) return NULL;
+       if (!queue->count) return NULL;
+
        node = LIST_ENTRY(queue_node, queue->head.next, item_link);
 
-       LIST_DEL(&node->item_link);
+       LIST_DELINIT(&node->item_link);
        queue->count--;
 
        return node;
@@ -295,7 +306,7 @@ _queue_node_pop_front(queue *queue)
 static queue_node *
 _queue_node_pop(queue *queue, queue_node *node)
 {
-       LIST_DEL(&node->item_link);
+       LIST_DELINIT(&node->item_link);
        queue->count--;
 
        return node;
@@ -347,6 +358,8 @@ _queue_get_node(tbm_surface_queue_h surface_queue, int type,
                }
        }
 
+       TBM_LOG_E("fail to get the queue_node.\n");
+
        return NULL;
 }
 
@@ -554,14 +567,6 @@ _tbm_surface_queue_dequeue(tbm_surface_queue_h surface_queue)
 {
        queue_node *node;
 
-       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 (_queue_is_empty(&surface_queue->free_queue))
-                       return NULL;
-       }
-
        node = _queue_node_pop_front(&surface_queue->free_queue);
 
        return node;
@@ -1080,7 +1085,11 @@ tbm_surface_queue_enqueue(tbm_surface_queue_h
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
-               return TBM_SURFACE_QUEUE_ERROR_ALREADY_EXIST;
+
+               if (!node)
+                       return TBM_SURFACE_QUEUE_ERROR_UNKNOWN_SURFACE;
+               else
+                       return TBM_SURFACE_QUEUE_ERROR_ALREADY_EXIST;
        }
 
        if (surface_queue->impl && surface_queue->impl->enqueue)
@@ -1093,7 +1102,7 @@ tbm_surface_queue_enqueue(tbm_surface_queue_h
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
-               return TBM_SURFACE_QUEUE_ERROR_UNKNOWN_SURFACE;
+               return TBM_SURFACE_QUEUE_ERROR_EMPTY;
        }
 
        node->type = QUEUE_NODE_TYPE_ENQUEUE;
@@ -1127,6 +1136,18 @@ tbm_surface_queue_dequeue(tbm_surface_queue_h
 
        pthread_mutex_lock(&surface_queue->lock);
 
+       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);
+                       pthread_mutex_unlock(&surface_queue->lock);
+                       _tbm_surf_queue_mutex_unlock();
+                       return TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
+               }
+       }
+
        if (surface_queue->impl && surface_queue->impl->dequeue)
                node = surface_queue->impl->dequeue(surface_queue);
        else
@@ -1137,7 +1158,7 @@ tbm_surface_queue_dequeue(tbm_surface_queue_h
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
-               return TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
+               return TBM_SURFACE_QUEUE_ERROR_EMPTY;
        }
 
        node->type = QUEUE_NODE_TYPE_DEQUEUE;
@@ -1181,6 +1202,7 @@ tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait)
 
                if (!_tbm_surface_queue_is_valid(surface_queue)) {
                        TBM_LOG_E("surface_queue:%p is invalid", surface_queue);
+                       pthread_mutex_unlock(&surface_queue->lock);
                        _tbm_surf_queue_mutex_unlock();
                        return 0;
                }
@@ -1199,10 +1221,10 @@ tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait)
                _tbm_surf_queue_mutex_lock();
 
                if (!_tbm_surface_queue_is_valid(surface_queue)) {
-                         TBM_LOG_E("surface_queue:%p is invalid", surface_queue);
+                       TBM_LOG_E("surface_queue:%p is invalid", surface_queue);
                        pthread_mutex_unlock(&surface_queue->lock);
-                         _tbm_surf_queue_mutex_unlock();
-                         return 0;
+                       _tbm_surf_queue_mutex_unlock();
+                       return 0;
                }
 
                pthread_mutex_unlock(&surface_queue->lock);
@@ -1240,7 +1262,11 @@ tbm_surface_queue_release(tbm_surface_queue_h
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
-               return TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
+
+               if (!node)
+                       return TBM_SURFACE_QUEUE_ERROR_UNKNOWN_SURFACE;
+               else
+                       return TBM_SURFACE_QUEUE_ERROR_ALREADY_EXIST;
        }
 
        if (surface_queue->queue_size < surface_queue->num_attached) {
@@ -1265,8 +1291,9 @@ tbm_surface_queue_release(tbm_surface_queue_h
        if (_queue_is_empty(&surface_queue->free_queue)) {
                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;
+               return TBM_SURFACE_QUEUE_ERROR_EMPTY;
        }
 
        node->type = QUEUE_NODE_TYPE_RELEASE;
@@ -1310,7 +1337,7 @@ tbm_surface_queue_acquire(tbm_surface_queue_h
                pthread_mutex_unlock(&surface_queue->lock);
 
                _tbm_surf_queue_mutex_unlock();
-               return TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
+               return TBM_SURFACE_QUEUE_ERROR_EMPTY;
        }
 
        node->type = QUEUE_NODE_TYPE_ACQUIRE;
@@ -1355,10 +1382,10 @@ tbm_surface_queue_can_acquire(tbm_surface_queue_h surface_queue, int wait)
                _tbm_surf_queue_mutex_lock();
 
                if (!_tbm_surface_queue_is_valid(surface_queue)) {
-                         TBM_LOG_E("surface_queue:%p is invalid", surface_queue);
+                       TBM_LOG_E("surface_queue:%p is invalid", surface_queue);
                        pthread_mutex_unlock(&surface_queue->lock);
-                         _tbm_surf_queue_mutex_unlock();
-                         return 0;
+                       _tbm_surf_queue_mutex_unlock();
+                       return 0;
                }
 
                pthread_mutex_unlock(&surface_queue->lock);
@@ -1549,6 +1576,42 @@ tbm_surface_queue_set_size(tbm_surface_queue_h
 }
 
 tbm_surface_queue_error_e
+tbm_surface_queue_free_flush(tbm_surface_queue_h surface_queue)
+{
+       queue_node *node = NULL;
+
+       _tbm_surf_queue_mutex_lock();
+
+       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);
+
+       if (surface_queue->num_attached == 0) {
+               _tbm_surf_queue_mutex_unlock();
+               return TBM_SURFACE_QUEUE_ERROR_NONE;
+       }
+
+       pthread_mutex_lock(&surface_queue->lock);
+
+       /* Destory surface in free_queue */
+       while ((node = _queue_node_pop_front(&surface_queue->free_queue))) {
+               if (surface_queue->impl && surface_queue->impl->need_detach)
+                       surface_queue->impl->need_detach(surface_queue, node);
+               else
+                       _tbm_surface_queue_detach(surface_queue, node->surface);
+       }
+
+       /* Reset queue */
+       _queue_init(&surface_queue->free_queue);
+
+       pthread_mutex_unlock(&surface_queue->lock);
+       _tbm_surf_queue_mutex_unlock();
+
+       return TBM_SURFACE_QUEUE_ERROR_NONE;
+}
+
+tbm_surface_queue_error_e
 tbm_surface_queue_flush(tbm_surface_queue_h surface_queue)
 {
        queue_node *node = NULL, *tmp;
@@ -1622,6 +1685,46 @@ tbm_surface_queue_get_surfaces(tbm_surface_queue_h surface_queue,
        return TBM_SURFACE_QUEUE_ERROR_NONE;
 }
 
+tbm_surface_queue_error_e
+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();
+
+       *num = 0;
+
+       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);
+
+       pthread_mutex_lock(&surface_queue->lock);
+
+       switch (trace) {
+       case TBM_SURFACE_QUEUE_TRACE_NONE:
+               *num = 0;
+               break;
+       case TBM_SURFACE_QUEUE_TRACE_DEQUEUE:
+               *num = _tbm_surface_queue_get_node_count(surface_queue, QUEUE_NODE_TYPE_DEQUEUE);
+               break;
+       case TBM_SURFACE_QUEUE_TRACE_ENQUEUE:
+               *num = _tbm_surface_queue_get_node_count(surface_queue, QUEUE_NODE_TYPE_ENQUEUE);
+               break;
+       case TBM_SURFACE_QUEUE_TRACE_ACQUIRE:
+               *num = _tbm_surface_queue_get_node_count(surface_queue, QUEUE_NODE_TYPE_ACQUIRE);
+               break;
+       case TBM_SURFACE_QUEUE_TRACE_RELEASE:
+               *num = _tbm_surface_queue_get_node_count(surface_queue, QUEUE_NODE_TYPE_RELEASE);
+               break;
+       }
+
+       pthread_mutex_unlock(&surface_queue->lock);
+
+       _tbm_surf_queue_mutex_unlock();
+
+       return TBM_SURFACE_QUEUE_ERROR_NONE;
+}
+
 typedef struct {
        int flags;
 } tbm_queue_default;
@@ -1648,6 +1751,7 @@ __tbm_queue_default_need_attach(tbm_surface_queue_h surface_queue)
                _tbm_surf_queue_mutex_lock();
                pthread_mutex_lock(&surface_queue->lock);
 
+               /* silent return */
                if (!surface)
                        return;
 
@@ -1696,6 +1800,7 @@ tbm_surface_queue_create(int queue_size, int width,
        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");
                free(surface_queue);
                _tbm_surf_queue_mutex_unlock();
                return NULL;
@@ -1755,6 +1860,7 @@ __tbm_queue_sequence_need_attach(tbm_surface_queue_h surface_queue)
                _tbm_surf_queue_mutex_lock();
                pthread_mutex_lock(&surface_queue->lock);
 
+               /* silent return */
                if (!surface)
                        return;
 
@@ -1836,6 +1942,7 @@ tbm_surface_queue_sequence_create(int queue_size, int width,
        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");
                free(surface_queue);
                _tbm_surf_queue_mutex_unlock();
                return NULL;