X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftbm_surface_queue.c;h=1dadcb000c0258d107568b326400a0a9094289d8;hb=bd2104fffed8a422aeef711893b8e458a2aea197;hp=277fda51c44c4645be8b88db7cd6b42ad964adb1;hpb=04b09e8330c418369f4f08319328db74bc1ce895;p=platform%2Fcore%2Fuifw%2Flibtbm.git diff --git a/src/tbm_surface_queue.c b/src/tbm_surface_queue.c index 277fda5..1dadcb0 100644 --- 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;