#include "tbm_bufmgr_int.h"
#include "list.h"
+#include <time.h>
#define FREE_QUEUE 1
#define DIRTY_QUEUE 2
int width, int height, int format,
const tbm_surface_queue_interface *impl, void *data)
{
+ pthread_condattr_t free_attr, dirty_attr;
+
TBM_RETURN_IF_FAIL(surface_queue != NULL);
TBM_RETURN_IF_FAIL(impl != NULL);
_init_tbm_surf_queue_bufmgr();
pthread_mutex_init(&surface_queue->lock, NULL);
- pthread_cond_init(&surface_queue->free_cond, NULL);
- pthread_cond_init(&surface_queue->dirty_cond, NULL);
+
+ pthread_condattr_init(&free_attr);
+ pthread_condattr_setclock(&free_attr, CLOCK_MONOTONIC);
+ pthread_cond_init(&surface_queue->free_cond, &free_attr);
+ pthread_condattr_destroy(&free_attr);
+
+ pthread_condattr_init(&dirty_attr);
+ pthread_condattr_setclock(&dirty_attr, CLOCK_MONOTONIC);
+ pthread_cond_init(&surface_queue->dirty_cond, &dirty_attr);
+ pthread_condattr_destroy(&dirty_attr);
surface_queue->queue_size = queue_size;
surface_queue->width = width;
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_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;
- }
}
if (surface_queue->impl && surface_queue->impl->dequeue)
return TBM_SURFACE_QUEUE_ERROR_NONE;
}
+tbm_surface_queue_error_e
+tbm_surface_queue_can_dequeue_wait_timeout(tbm_surface_queue_h surface_queue, int ms_timeout)
+{
+ int ret;
+ struct timespec tp;
+
+ _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->can_dequeue_noti);
+
+ _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_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 (!_queue_is_empty(&surface_queue->free_queue)) {
+ pthread_mutex_unlock(&surface_queue->lock);
+ _tbm_surf_queue_mutex_unlock();
+ return TBM_SURFACE_QUEUE_ERROR_NONE;
+ }
+
+ _tbm_surf_queue_mutex_unlock();
+
+ while (1) {
+ clock_gettime(CLOCK_MONOTONIC, &tp);
+
+ if (ms_timeout > 1000)
+ tp.tv_sec += ms_timeout / 1000;
+
+ tp.tv_nsec += (ms_timeout % 1000) * 1000000;
+
+ if (tp.tv_nsec > 1000000000L) {
+ tp.tv_sec++;
+ tp.tv_nsec -= 1000000000L;
+ }
+
+ ret = pthread_cond_timedwait(&surface_queue->free_cond, &surface_queue->lock, &tp);
+ if (ret) {
+ if (ret == ETIMEDOUT) {
+ TBM_ERR("surface_queue:%p can dequeue wait timeout", surface_queue);
+ pthread_mutex_unlock(&surface_queue->lock);
+ return TBM_SURFACE_QUEUE_ERROR_TIMEOUT;
+ } else {
+ TBM_INFO("surface_queue:%p timedwait error retry wait", surface_queue);
+ }
+ } else {
+ pthread_mutex_unlock(&surface_queue->lock);
+ return TBM_SURFACE_QUEUE_ERROR_NONE;
+ }
+ }
+}
+
int
tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait)
{
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_ERR("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)) {
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);
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);
}
tbm_surface_queue_error_e
+tbm_surface_queue_get_acquirable_surfaces(tbm_surface_queue_h surface_queue,
+ tbm_surface_h *surfaces, int *num)
+{
+ queue_node *node = 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,
+ TBM_ERROR_INVALID_PARAMETER);
+
+ pthread_mutex_lock(&surface_queue->lock);
+
+ LIST_FOR_EACH_ENTRY(node, &surface_queue->dirty_queue.head, item_link) {
+ if (surfaces)
+ surfaces[*num] = node->surface;
+
+ *num = *num + 1;
+ }
+
+ 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_get_trace_surface_num(
tbm_surface_queue_h surface_queue, tbm_surface_queue_trace trace, int *num)
{
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;
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)