**************************************************************************/
+#include "config.h"
+
#include "tbm_bufmgr_int.h"
#include "list.h"
void *data;
} queue_notify;
+typedef struct {
+ struct list_head link;
+
+ tbm_surface_queue_trace_cb cb;
+ void *data;
+} queue_trace;
+
typedef struct _tbm_surface_queue_interface {
void (*init)(tbm_surface_queue_h queue);
void (*reset)(tbm_surface_queue_h queue);
void (*release)(tbm_surface_queue_h queue, queue_node *node);
queue_node *(*dequeue)(tbm_surface_queue_h queue);
queue_node *(*acquire)(tbm_surface_queue_h queue);
+ void (*need_detach)(tbm_surface_queue_h queue, queue_node *node);
} tbm_surface_queue_interface;
struct _tbm_surface_queue {
int height;
int format;
int queue_size;
+ int num_attached;
queue free_queue;
queue dirty_queue;
struct list_head destory_noti;
struct list_head dequeuable_noti;
struct list_head dequeue_noti;
+ struct list_head can_dequeue_noti;
struct list_head acquirable_noti;
struct list_head reset_noti;
+ struct list_head trace_noti;
pthread_mutex_t lock;
pthread_cond_t free_cond;
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;
}
return true;
}
-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);
}
-void
+static void
_tbm_surf_queue_mutex_unlock(void)
{
pthread_mutex_unlock(&tbm_surf_queue_lock);
static int
_tbm_surface_queue_is_valid(tbm_surface_queue_h surface_queue)
{
- tbm_surface_queue_h old_data = NULL, tmp = NULL;
+ tbm_surface_queue_h old_data = NULL;
- if (surface_queue == NULL || g_surf_queue_bufmgr == NULL) {
- TBM_TRACE("error: tbm_surface_queue(%p)\n", surface_queue);
+ if (surface_queue == NULL) {
+ TBM_LOG_E("error: surface_queue is NULL.\n");
return 0;
}
- if (!LIST_IS_EMPTY(&g_surf_queue_bufmgr->surf_queue_list)) {
- LIST_FOR_EACH_ENTRY_SAFE(old_data, tmp, &g_surf_queue_bufmgr->surf_queue_list, item_link) {
- if (old_data == surface_queue) {
- TBM_TRACE("tbm_surface_queue(%p)\n", surface_queue);
- return 1;
- }
+ 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_LOG_E("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);
+ return 1;
}
}
- TBM_TRACE("error: tbm_surface_queue(%p)\n", surface_queue);
+
+ TBM_LOG_E("error: Invalid tbm_surface_queue(%p)\n", surface_queue);
+
return 0;
}
static queue_node *
_queue_node_pop_front(queue *queue)
{
- queue_node *node = NULL;
+ 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;
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;
tbm_surface_h surface, int *out_type)
{
queue_node *node = NULL;
- queue_node *tmp = NULL;
if (type == 0)
type = FREE_QUEUE | DIRTY_QUEUE | NODE_LIST;
*out_type = 0;
if (type & FREE_QUEUE) {
- LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->free_queue.head,
+ LIST_FOR_EACH_ENTRY(node, &surface_queue->free_queue.head,
item_link) {
if (node->surface == surface) {
if (out_type)
}
if (type & DIRTY_QUEUE) {
- LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->dirty_queue.head,
+ LIST_FOR_EACH_ENTRY(node, &surface_queue->dirty_queue.head,
item_link) {
if (node->surface == surface) {
if (out_type)
}
if (type & NODE_LIST) {
- LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->list, link) {
+ LIST_FOR_EACH_ENTRY(node, &surface_queue->list, link) {
if (node->surface == surface) {
if (out_type)
*out_type = NODE_LIST;
}
}
+ TBM_LOG_E("fail to get the queue_node.\n");
+
return NULL;
}
_notify_remove(struct list_head *list,
tbm_surface_queue_notify_cb cb, void *data)
{
- queue_notify *item = NULL, *tmp = NULL;
+ queue_notify *item = NULL, *tmp;
LIST_FOR_EACH_ENTRY_SAFE(item, tmp, list, link) {
if (item->cb == cb && item->data == data) {
static void
_notify_remove_all(struct list_head *list)
{
- queue_notify *item = NULL, *tmp = NULL;
+ queue_notify *item = NULL, *tmp;
LIST_FOR_EACH_ENTRY_SAFE(item, tmp, list, link) {
LIST_DEL(&item->link);
_notify_emit(tbm_surface_queue_h surface_queue,
struct list_head *list)
{
- queue_notify *item = NULL, *tmp = NULL;
+ queue_notify *item = NULL, *tmp;;
- LIST_FOR_EACH_ENTRY_SAFE(item, tmp, list, link) {
+ /*
+ The item->cb is the outside function of the libtbm.
+ The tbm user may/can remove the item of the list,
+ so we have to use the LIST_FOR_EACH_ENTRY_SAFE.
+ */
+ LIST_FOR_EACH_ENTRY_SAFE(item, tmp, list, link)
item->cb(surface_queue, item->data);
+}
+
+static void
+_trace_add(struct list_head *list, tbm_surface_queue_trace_cb cb,
+ void *data)
+{
+ TBM_RETURN_IF_FAIL(cb != NULL);
+
+ queue_trace *item = (queue_trace *)calloc(1, sizeof(queue_trace));
+
+ TBM_RETURN_IF_FAIL(item != NULL);
+
+ LIST_INITHEAD(&item->link);
+ item->cb = cb;
+ item->data = data;
+
+ LIST_ADDTAIL(&item->link, list);
+}
+
+static void
+_trace_remove(struct list_head *list,
+ tbm_surface_queue_trace_cb cb, void *data)
+{
+ queue_trace *item = NULL, *tmp;
+
+ LIST_FOR_EACH_ENTRY_SAFE(item, tmp, list, link) {
+ if (item->cb == cb && item->data == data) {
+ LIST_DEL(&item->link);
+ free(item);
+ return;
+ }
+ }
+
+ TBM_LOG_E("Cannot find notifiy\n");
+}
+
+static void
+_trace_remove_all(struct list_head *list)
+{
+ queue_trace *item = NULL, *tmp;
+
+ LIST_FOR_EACH_ENTRY_SAFE(item, tmp, list, link) {
+ LIST_DEL(&item->link);
+ free(item);
}
}
+static void
+_trace_emit(tbm_surface_queue_h surface_queue,
+ struct list_head *list, tbm_surface_h surface, tbm_surface_queue_trace trace)
+{
+ queue_trace *item = NULL, *tmp;;
+
+ /*
+ The item->cb is the outside function of the libtbm.
+ The tbm user may/can remove the item of the list,
+ so we have to use the LIST_FOR_EACH_ENTRY_SAFE.
+ */
+ LIST_FOR_EACH_ENTRY_SAFE(item, tmp, list, link)
+ item->cb(surface_queue, surface, trace, item->data);
+}
+
static int
_tbm_surface_queue_get_node_count(tbm_surface_queue_h surface_queue, Queue_Node_Type type)
{
queue_node *node = NULL;
- queue_node *tmp = NULL;
int count = 0;
- LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->list, link) {
+ LIST_FOR_EACH_ENTRY(node, &surface_queue->list, link) {
if (node->type == type)
count++;
}
return count;
}
-void
+static void
_tbm_surface_queue_attach(tbm_surface_queue_h surface_queue,
tbm_surface_h surface)
{
- queue_node *node = NULL;
+ queue_node *node;
node = _queue_node_create();
TBM_RETURN_IF_FAIL(node != NULL);
node->surface = surface;
LIST_ADDTAIL(&node->link, &surface_queue->list);
+ surface_queue->num_attached++;
_queue_node_push_back(&surface_queue->free_queue, node);
}
-void
+static void
_tbm_surface_queue_detach(tbm_surface_queue_h surface_queue,
tbm_surface_h surface)
{
- queue_node *node = NULL;
+ queue_node *node;
int queue_type;
node = _queue_get_node(surface_queue, 0, surface, &queue_type);
- if (node)
+ if (node) {
_queue_delete_node(surface_queue, node);
+ surface_queue->num_attached--;
+ }
}
-void
+static void
_tbm_surface_queue_enqueue(tbm_surface_queue_h surface_queue,
queue_node *node, int push_back)
{
_queue_node_push_front(&surface_queue->dirty_queue, node);
}
-queue_node *
+static queue_node *
_tbm_surface_queue_dequeue(tbm_surface_queue_h surface_queue)
{
- queue_node *node = NULL;
-
- 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;
- }
+ queue_node *node;
node = _queue_node_pop_front(&surface_queue->free_queue);
return node;
}
-queue_node *
+static queue_node *
_tbm_surface_queue_acquire(tbm_surface_queue_h surface_queue)
{
- queue_node *node = NULL;
+ queue_node *node;
if (_queue_is_empty(&surface_queue->dirty_queue))
return NULL;
return node;
}
-void
+static void
_tbm_surface_queue_release(tbm_surface_queue_h surface_queue,
queue_node *node, int push_back)
{
_queue_node_push_front(&surface_queue->free_queue, node);
}
-void
+static void
_tbm_surface_queue_init(tbm_surface_queue_h surface_queue,
int queue_size,
int width, int height, int format,
TBM_RETURN_IF_FAIL(surface_queue != NULL);
TBM_RETURN_IF_FAIL(impl != NULL);
- memset(surface_queue, 0x00, sizeof(struct _tbm_surface_queue));
-
if (!g_surf_queue_bufmgr)
_init_tbm_surf_queue_bufmgr();
LIST_INITHEAD(&surface_queue->list);
LIST_INITHEAD(&surface_queue->destory_noti);
- LIST_INITHEAD(&surface_queue->acquirable_noti);
LIST_INITHEAD(&surface_queue->dequeuable_noti);
LIST_INITHEAD(&surface_queue->dequeue_noti);
+ LIST_INITHEAD(&surface_queue->can_dequeue_noti);
+ LIST_INITHEAD(&surface_queue->acquirable_noti);
LIST_INITHEAD(&surface_queue->reset_noti);
+ LIST_INITHEAD(&surface_queue->trace_noti);
if (surface_queue->impl && surface_queue->impl->init)
surface_queue->impl->init(surface_queue);
}
tbm_surface_queue_error_e
+tbm_surface_queue_add_can_dequeue_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb,
+ void *data)
+{
+ _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);
+
+ pthread_mutex_lock(&surface_queue->lock);
+
+ TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+
+ _notify_add(&surface_queue->can_dequeue_noti, can_dequeue_cb, data);
+
+ 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_remove_can_dequeue_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb,
+ void *data)
+{
+ _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);
+
+ pthread_mutex_lock(&surface_queue->lock);
+
+ TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+
+ _notify_remove(&surface_queue->can_dequeue_noti, can_dequeue_cb, data);
+
+ 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_add_acquirable_cb(
tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb,
void *data)
}
tbm_surface_queue_error_e
+tbm_surface_queue_add_trace_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb,
+ void *data)
+{
+ _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);
+
+ pthread_mutex_lock(&surface_queue->lock);
+
+ TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+
+ _trace_add(&surface_queue->trace_noti, trace_cb, data);
+
+ 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_remove_trace_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb,
+ void *data)
+{
+ _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);
+
+ pthread_mutex_lock(&surface_queue->lock);
+
+ TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+
+ _trace_remove(&surface_queue->trace_noti, trace_cb, data);
+
+ 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_set_alloc_cb(
tbm_surface_queue_h surface_queue,
tbm_surface_alloc_cb alloc_cb,
tbm_surface_queue_enqueue(tbm_surface_queue_h
surface_queue, tbm_surface_h surface)
{
- queue_node *node = NULL;
+ queue_node *node;
int queue_type;
_tbm_surf_queue_mutex_lock();
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 exist in free_queue or dirty_queue node:%p, queue:%d\n",
+ TBM_LOG_E("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();
- 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->impl && surface_queue->impl->enqueue)
pthread_mutex_unlock(&surface_queue->lock);
_tbm_surf_queue_mutex_unlock();
- return TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
+ return TBM_SURFACE_QUEUE_ERROR_EMPTY;
}
node->type = QUEUE_NODE_TYPE_ENQUEUE;
_tbm_surf_queue_mutex_unlock();
+ _trace_emit(surface_queue, &surface_queue->trace_noti, surface, TBM_SURFACE_QUEUE_TRACE_ENQUEUE);
+
_notify_emit(surface_queue, &surface_queue->acquirable_noti);
return TBM_SURFACE_QUEUE_ERROR_NONE;
tbm_surface_queue_dequeue(tbm_surface_queue_h
surface_queue, tbm_surface_h *surface)
{
- queue_node *node = NULL;
+ queue_node *node;
_tbm_surf_queue_mutex_lock();
+ *surface = NULL;
+
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(surface != NULL,
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
node = _tbm_surface_queue_dequeue(surface_queue);
- if (node == NULL) {
- *surface = NULL;
+ if (node == NULL || node->surface == NULL) {
+ TBM_LOG_E("_queue_node_pop_front failed\n");
pthread_mutex_unlock(&surface_queue->lock);
_tbm_surf_queue_mutex_unlock();
return TBM_SURFACE_QUEUE_ERROR_EMPTY;
}
- if (node->surface == NULL) {
- *surface = NULL;
- TBM_LOG_E("_queue_node_pop_front failed\n");
- pthread_mutex_unlock(&surface_queue->lock);
-
- _tbm_surf_queue_mutex_unlock();
- return TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
- }
-
node->type = QUEUE_NODE_TYPE_DEQUEUE;
*surface = node->surface;
_tbm_surf_queue_mutex_unlock();
+ _trace_emit(surface_queue, &surface_queue->trace_noti, *surface, TBM_SURFACE_QUEUE_TRACE_DEQUEUE);
+
_notify_emit(surface_queue, &surface_queue->dequeue_noti);
return TBM_SURFACE_QUEUE_ERROR_NONE;
TBM_SURF_QUEUE_RETURN_VAL_IF_FAIL(_tbm_surface_queue_is_valid(surface_queue), 0);
+ _tbm_surf_queue_mutex_unlock();
+
+ _notify_emit(surface_queue, &surface_queue->can_dequeue_noti);
+
+ _tbm_surf_queue_mutex_lock();
+
+ 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);
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_surf_queue_mutex_unlock();
- return 0;
+ TBM_LOG_E("surface_queue:%p is invalid", surface_queue);
+ pthread_mutex_unlock(&surface_queue->lock);
+ _tbm_surf_queue_mutex_unlock();
+ return 0;
}
}
- if (_queue_is_empty(&surface_queue->free_queue)) {
- if (wait &&
- _tbm_surface_queue_get_node_count(surface_queue, QUEUE_NODE_TYPE_ACQUIRE)) {
-
- _tbm_surf_queue_mutex_unlock();
-
- pthread_cond_wait(&surface_queue->free_cond, &surface_queue->lock);
-
- _tbm_surf_queue_mutex_lock();
+ if (!_queue_is_empty(&surface_queue->free_queue)) {
+ pthread_mutex_unlock(&surface_queue->lock);
+ _tbm_surf_queue_mutex_unlock();
+ return 1;
+ }
- if (!_tbm_surface_queue_is_valid(surface_queue)) {
- TBM_LOG_E("surface_queue:%p is invalid", surface_queue);
- _tbm_surf_queue_mutex_unlock();
- return 0;
- }
+ if (wait && _tbm_surface_queue_get_node_count(surface_queue,
+ QUEUE_NODE_TYPE_ACQUIRE)) {
+ _tbm_surf_queue_mutex_unlock();
+ pthread_cond_wait(&surface_queue->free_cond, &surface_queue->lock);
+ _tbm_surf_queue_mutex_lock();
+ 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 1;
+ return 0;
}
pthread_mutex_unlock(&surface_queue->lock);
-
_tbm_surf_queue_mutex_unlock();
- return 0;
+ return 1;
}
pthread_mutex_unlock(&surface_queue->lock);
-
_tbm_surf_queue_mutex_unlock();
-
- return 1;
+ return 0;
}
tbm_surface_queue_error_e
tbm_surface_queue_release(tbm_surface_queue_h
surface_queue, tbm_surface_h surface)
{
- queue_node *node = NULL;
+ queue_node *node;
int queue_type;
_tbm_surf_queue_mutex_lock();
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 exist in free_queue or dirty_queue node:%p, queue:%d\n",
+ TBM_LOG_E("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();
- 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) {
+ TBM_QUEUE_TRACE("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);
+ else
+ _tbm_surface_queue_detach(surface_queue, surface);
+
+ pthread_mutex_unlock(&surface_queue->lock);
+
+ _tbm_surf_queue_mutex_unlock();
+ return TBM_SURFACE_QUEUE_ERROR_NONE;
}
if (surface_queue->impl && surface_queue->impl->release)
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_NONE;
+ return TBM_SURFACE_QUEUE_ERROR_EMPTY;
}
node->type = QUEUE_NODE_TYPE_RELEASE;
_tbm_surf_queue_mutex_unlock();
+ _trace_emit(surface_queue, &surface_queue->trace_noti, surface, TBM_SURFACE_QUEUE_TRACE_RELEASE);
+
_notify_emit(surface_queue, &surface_queue->dequeuable_noti);
return TBM_SURFACE_QUEUE_ERROR_NONE;
tbm_surface_queue_acquire(tbm_surface_queue_h
surface_queue, tbm_surface_h *surface)
{
- queue_node *node = NULL;
+ queue_node *node;
_tbm_surf_queue_mutex_lock();
+ *surface = NULL;
+
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(surface != NULL,
else
node = _tbm_surface_queue_acquire(surface_queue);
- if (node == NULL) {
- *surface = NULL;
+ if (node == NULL || node->surface == NULL) {
+ TBM_LOG_E("_queue_node_pop_front failed\n");
pthread_mutex_unlock(&surface_queue->lock);
_tbm_surf_queue_mutex_unlock();
return TBM_SURFACE_QUEUE_ERROR_EMPTY;
}
- if (node->surface == NULL) {
- *surface = NULL;
- TBM_LOG_E("_queue_node_pop_front failed\n");
- pthread_mutex_unlock(&surface_queue->lock);
-
- _tbm_surf_queue_mutex_unlock();
- return TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
- }
-
node->type = QUEUE_NODE_TYPE_ACQUIRE;
*surface = node->surface;
if (b_dump_queue)
tbm_surface_internal_dump_buffer(*surface, "acquire");
+ _trace_emit(surface_queue, &surface_queue->trace_noti, *surface, TBM_SURFACE_QUEUE_TRACE_ACQUIRE);
+
return TBM_SURFACE_QUEUE_ERROR_NONE;
}
TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
- if (_queue_is_empty(&surface_queue->dirty_queue)) {
- if (wait &&
- _tbm_surface_queue_get_node_count(surface_queue, QUEUE_NODE_TYPE_DEQUEUE)) {
-
- _tbm_surf_queue_mutex_unlock();
-
- pthread_cond_wait(&surface_queue->dirty_cond, &surface_queue->lock);
-
- _tbm_surf_queue_mutex_lock();
+ if (!_queue_is_empty(&surface_queue->dirty_queue)) {
+ pthread_mutex_unlock(&surface_queue->lock);
+ _tbm_surf_queue_mutex_unlock();
+ return 1;
+ }
- if (!_tbm_surface_queue_is_valid(surface_queue)) {
- TBM_LOG_E("surface_queue:%p is invalid", surface_queue);
- _tbm_surf_queue_mutex_unlock();
- return 0;
- }
+ if (wait && _tbm_surface_queue_get_node_count(surface_queue,
+ QUEUE_NODE_TYPE_DEQUEUE)) {
+ _tbm_surf_queue_mutex_unlock();
+ pthread_cond_wait(&surface_queue->dirty_cond, &surface_queue->lock);
+ _tbm_surf_queue_mutex_lock();
+ 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 1;
+ return 0;
}
pthread_mutex_unlock(&surface_queue->lock);
-
_tbm_surf_queue_mutex_unlock();
- return 0;
+ return 1;
}
pthread_mutex_unlock(&surface_queue->lock);
-
_tbm_surf_queue_mutex_unlock();
-
- return 1;
+ return 0;
}
void
tbm_surface_queue_destroy(tbm_surface_queue_h surface_queue)
{
- queue_node *node = NULL, *tmp = NULL;
+ queue_node *node = NULL, *tmp;
_tbm_surf_queue_mutex_lock();
TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
- LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->list, link) {
+ LIST_DEL(&surface_queue->item_link);
+
+ LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->list, link)
_queue_delete_node(surface_queue, node);
- }
if (surface_queue->impl && surface_queue->impl->destroy)
surface_queue->impl->destroy(surface_queue);
_notify_emit(surface_queue, &surface_queue->destory_noti);
_notify_remove_all(&surface_queue->destory_noti);
- _notify_remove_all(&surface_queue->acquirable_noti);
_notify_remove_all(&surface_queue->dequeuable_noti);
+ _notify_remove_all(&surface_queue->dequeue_noti);
+ _notify_remove_all(&surface_queue->can_dequeue_noti);
+ _notify_remove_all(&surface_queue->acquirable_noti);
_notify_remove_all(&surface_queue->reset_noti);
+ _trace_remove_all(&surface_queue->trace_noti);
pthread_mutex_destroy(&surface_queue->lock);
- LIST_DEL(&surface_queue->item_link);
-
free(surface_queue);
- surface_queue = NULL;
if (LIST_IS_EMPTY(&g_surf_queue_bufmgr->surf_queue_list))
_deinit_tbm_surf_queue_bufmgr();
tbm_surface_queue_reset(tbm_surface_queue_h
surface_queue, int width, int height, int format)
{
- queue_node *node = NULL, *tmp = NULL;
+ queue_node *node = NULL, *tmp;
_tbm_surf_queue_mutex_lock();
TBM_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
if (width == surface_queue->width && height == surface_queue->height &&
- format == surface_queue->format) {
+ format == surface_queue->format) {
_tbm_surf_queue_mutex_unlock();
return TBM_SURFACE_QUEUE_ERROR_NONE;
}
surface_queue->format = format;
/* Destory surface and Push to free_queue */
- LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->list, link) {
+ LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->list, link)
_queue_delete_node(surface_queue, node);
- }
/* Reset queue */
_queue_init(&surface_queue->free_queue);
_queue_init(&surface_queue->dirty_queue);
LIST_INITHEAD(&surface_queue->list);
+ surface_queue->num_attached = 0;
+
if (surface_queue->impl && surface_queue->impl->reset)
surface_queue->impl->reset(surface_queue);
}
tbm_surface_queue_error_e
-tbm_surface_queue_flush(tbm_surface_queue_h surface_queue)
+tbm_surface_queue_notify_reset(tbm_surface_queue_h surface_queue)
{
- queue_node *node = NULL, *tmp = 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_surf_queue_mutex_unlock();
+
+ _notify_emit(surface_queue, &surface_queue->reset_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_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_QUEUE_TRACE("tbm_surface_queue(%p)\n", surface_queue);
+
+ if ((surface_queue->queue_size == queue_size) && !flush) {
+ _tbm_surf_queue_mutex_unlock();
+ return TBM_SURFACE_QUEUE_ERROR_NONE;
+ }
+
+ pthread_mutex_lock(&surface_queue->lock);
+
+ if (flush) {
+ /* Destory surface and Push to free_queue */
+ LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->list, link)
+ _queue_delete_node(surface_queue, node);
+
+ /* Reset queue */
+ _queue_init(&surface_queue->free_queue);
+ _queue_init(&surface_queue->dirty_queue);
+ LIST_INITHEAD(&surface_queue->list);
+
+ 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);
+
+ pthread_mutex_unlock(&surface_queue->lock);
+ pthread_cond_signal(&surface_queue->free_cond);
+
+ _tbm_surf_queue_mutex_unlock();
+
+ _notify_emit(surface_queue, &surface_queue->reset_noti);
+
+ return TBM_SURFACE_QUEUE_ERROR_NONE;
+ } else {
+ if (surface_queue->queue_size > queue_size) {
+ 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);
+
+ 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);
+
+ need_del--;
+ if (need_del == 0)
+ break;
+ }
+ }
+
+ surface_queue->queue_size = queue_size;
+
+ 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_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;
+
+ _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 and Push to free_queue */
- LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->list, link) {
+ LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->list, link)
_queue_delete_node(surface_queue, node);
- }
/* Reset queue */
_queue_init(&surface_queue->free_queue);
_queue_init(&surface_queue->dirty_queue);
LIST_INITHEAD(&surface_queue->list);
+ surface_queue->num_attached = 0;
+
if (surface_queue->impl && surface_queue->impl->reset)
surface_queue->impl->reset(surface_queue);
tbm_surface_h *surfaces, int *num)
{
queue_node *node = NULL;
- queue_node *tmp = NULL;
_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,
pthread_mutex_lock(&surface_queue->lock);
- *num = 0;
- LIST_FOR_EACH_ENTRY_SAFE(node, tmp, &surface_queue->list, link) {
+ LIST_FOR_EACH_ENTRY(node, &surface_queue->list, link) {
if (surfaces)
surfaces[*num] = node->surface;
return TBM_SURFACE_QUEUE_ERROR_NONE;
}
-typedef struct {
- int queue_size;
- int num_attached;
- int flags;
-} tbm_queue_default;
-
-static void
-__tbm_queue_default_init(tbm_surface_queue_h surface_queue)
+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_queue_default *data = surface_queue->impl_data;
+ _tbm_surf_queue_mutex_lock();
- data->num_attached = 0;
-}
+ *num = 0;
-static void
-__tbm_queue_default_reset(tbm_surface_queue_h surface_queue)
-{
- tbm_queue_default *data = surface_queue->impl_data;
+ 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);
- data->num_attached = 0;
+ 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;
+
static void
__tbm_queue_default_destroy(tbm_surface_queue_h surface_queue)
{
static void
__tbm_queue_default_need_attach(tbm_surface_queue_h surface_queue)
{
- tbm_queue_default *data = surface_queue->impl_data;
+ tbm_queue_default *data = (tbm_queue_default *)surface_queue->impl_data;
tbm_surface_h surface;
- if (data->queue_size == data->num_attached)
+ if (surface_queue->queue_size == surface_queue->num_attached)
return;
if (surface_queue->alloc_cb) {
+ pthread_mutex_unlock(&surface_queue->lock);
_tbm_surf_queue_mutex_unlock();
surface = surface_queue->alloc_cb(surface_queue, surface_queue->alloc_cb_data);
_tbm_surf_queue_mutex_lock();
+ pthread_mutex_lock(&surface_queue->lock);
+ /* silent return */
if (!surface)
return;
_tbm_surface_queue_attach(surface_queue, surface);
tbm_surface_internal_unref(surface);
- data->num_attached++;
}
static const tbm_surface_queue_interface tbm_queue_default_impl = {
- __tbm_queue_default_init,
- __tbm_queue_default_reset,
+ NULL, /*__tbm_queue_default_init*/
+ NULL, /*__tbm_queue_default_reset*/
__tbm_queue_default_destroy,
__tbm_queue_default_need_attach,
NULL, /*__tbm_queue_default_enqueue*/
NULL, /*__tbm_queue_default_release*/
NULL, /*__tbm_queue_default_dequeue*/
NULL, /*__tbm_queue_default_acquire*/
+ NULL, /*__tbm_queue_default_need_detach*/
};
tbm_surface_queue_h
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;
}
- data->queue_size = queue_size;
data->flags = flags;
_tbm_surface_queue_init(surface_queue,
- data->queue_size,
+ queue_size,
width, height, format,
&tbm_queue_default_impl, data);
}
typedef struct {
- int queue_size;
- int num_attached;
int flags;
queue dequeue_list;
} tbm_queue_sequence;
static void
__tbm_queue_sequence_init(tbm_surface_queue_h surface_queue)
{
- tbm_queue_sequence *data = surface_queue->impl_data;
+ tbm_queue_sequence *data = (tbm_queue_sequence *)surface_queue->impl_data;
- data->num_attached = 0;
_queue_init(&data->dequeue_list);
}
static void
__tbm_queue_sequence_reset(tbm_surface_queue_h surface_queue)
{
- tbm_queue_sequence *data = surface_queue->impl_data;
+ tbm_queue_sequence *data = (tbm_queue_sequence *)surface_queue->impl_data;
- data->num_attached = 0;
_queue_init(&data->dequeue_list);
}
static void
__tbm_queue_sequence_need_attach(tbm_surface_queue_h surface_queue)
{
- tbm_queue_sequence *data = surface_queue->impl_data;
+ tbm_queue_sequence *data = (tbm_queue_sequence *)surface_queue->impl_data;
tbm_surface_h surface;
- if (data->queue_size == data->num_attached)
+ if (surface_queue->queue_size == surface_queue->num_attached)
return;
if (surface_queue->alloc_cb) {
+ pthread_mutex_unlock(&surface_queue->lock);
_tbm_surf_queue_mutex_unlock();
surface = surface_queue->alloc_cb(surface_queue, surface_queue->alloc_cb_data);
_tbm_surf_queue_mutex_lock();
+ pthread_mutex_lock(&surface_queue->lock);
+ /* silent return */
if (!surface)
return;
_tbm_surface_queue_attach(surface_queue, surface);
tbm_surface_internal_unref(surface);
- data->num_attached++;
}
static void
__tbm_queue_sequence_enqueue(tbm_surface_queue_h surface_queue,
queue_node *node)
{
- tbm_queue_sequence *data = surface_queue->impl_data;
- queue_node *next = NULL;
- queue_node *tmp = NULL;
+ tbm_queue_sequence *data = (tbm_queue_sequence *)surface_queue->impl_data;
+ queue_node *next = NULL, *tmp;
node->priv_flags = 0;
__tbm_queue_sequence_dequeue(tbm_surface_queue_h
surface_queue)
{
- tbm_queue_sequence *data = surface_queue->impl_data;
- queue_node *node = NULL;
+ tbm_queue_sequence *data = (tbm_queue_sequence *)surface_queue->impl_data;
+ queue_node *node;
node = _tbm_surface_queue_dequeue(surface_queue);
if (node) {
NULL, /*__tbm_queue_sequence_release*/
__tbm_queue_sequence_dequeue,
NULL, /*__tbm_queue_sequence_acquire*/
+ NULL, /*__tbm_queue_sequence_need_dettach*/
};
tbm_surface_queue_h
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;
}
- data->queue_size = queue_size;
data->flags = flags;
_tbm_surface_queue_init(surface_queue,
- data->queue_size,
+ queue_size,
width, height, format,
&tbm_queue_sequence_impl, data);
projects / platform / core / uifw / libtbm.git / blobdiff