vblank: interval should be greater than 0

[platform/core/uifw/libtdm.git] / src / tdm_layer.c

diff --git a/src/tdm_layer.c b/src/tdm_layer.c
index 2f97c5c..97e2a09 100644 (file)
--- a/src/tdm_layer.c
+++ b/src/tdm_layer.c
@@ -80,6 +80,25 @@ static void _tdm_layer_cb_output_commit(tdm_output *output, unsigned int sequenc
                                                                                unsigned int tv_sec, unsigned int tv_usec, void *user_data);
 static void _tdm_layer_reset_pending_data(tdm_private_layer *private_layer);
 
+EXTERN tdm_output*
+tdm_layer_get_output(tdm_layer *layer, tdm_error *error)
+{
+       tdm_output *output;
+
+       LAYER_FUNC_ENTRY_ERROR();
+
+       _pthread_mutex_lock(&private_display->lock);
+
+       if (error)
+               *error = TDM_ERROR_NONE;
+
+       output = private_layer->private_output;
+
+       _pthread_mutex_unlock(&private_display->lock);
+
+       return output;
+}
+
 EXTERN tdm_error
 tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
 {
@@ -151,12 +170,14 @@ tdm_layer_get_zpos(tdm_layer *layer, int *zpos)
 EXTERN tdm_error
 tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
 {
+       tdm_private_backend *private_backend;
        tdm_func_layer *func_layer;
        LAYER_FUNC_ENTRY();
 
        _pthread_mutex_lock(&private_display->lock);
 
-       func_layer = &private_display->func_layer;
+       private_backend = private_layer->private_backend;
+       func_layer = &private_backend->func_layer;
 
        if (private_layer->usable)
                TDM_INFO("layer(%d) not usable", private_layer->index);
@@ -181,6 +202,7 @@ tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
 EXTERN tdm_error
 tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
 {
+       tdm_private_backend *private_backend;
        tdm_func_layer *func_layer;
        LAYER_FUNC_ENTRY();
 
@@ -188,7 +210,8 @@ tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
 
        _pthread_mutex_lock(&private_display->lock);
 
-       func_layer = &private_display->func_layer;
+       private_backend = private_layer->private_backend;
+       func_layer = &private_backend->func_layer;
 
        if (!func_layer->layer_get_property) {
                /* LCOV_EXCL_START */
@@ -208,12 +231,12 @@ tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
 INTERN tdm_error
 tdm_layer_set_info_internal(tdm_private_layer *private_layer, tdm_info_layer *info)
 {
-       tdm_private_output *private_output = private_layer->private_output;
-       tdm_private_display *private_display = private_output->private_display;
+       tdm_private_backend *private_backend;
        tdm_func_layer *func_layer;
        char fmtstr[128];
 
-       func_layer = &private_display->func_layer;
+       private_backend = private_layer->private_backend;
+       func_layer = &private_backend->func_layer;
 
        if (private_layer->usable)
                TDM_INFO("layer(%p) not usable", private_layer);
@@ -266,6 +289,7 @@ tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
 EXTERN tdm_error
 tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
 {
+       tdm_private_backend *private_backend;
        tdm_func_layer *func_layer;
        LAYER_FUNC_ENTRY();
 
@@ -273,7 +297,8 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
 
        _pthread_mutex_lock(&private_display->lock);
 
-       func_layer = &private_display->func_layer;
+       private_backend = private_layer->private_backend;
+       func_layer = &private_backend->func_layer;
 
        if (!func_layer->layer_get_info) {
                /* LCOV_EXCL_START */
@@ -418,8 +443,8 @@ _tdm_layer_free_all_buffers(tdm_private_layer *private_layer)
 INTERN tdm_error
 tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h buffer)
 {
+       tdm_private_backend *private_backend;
        tdm_private_output *private_output = private_layer->private_output;
-       tdm_private_display *private_display = private_output->private_display;
        tdm_func_layer *func_layer;
 
        /* LCOV_EXCL_START */
@@ -437,7 +462,8 @@ tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h bu
        }
        /* LCOV_EXCL_STOP */
 
-       func_layer = &private_display->func_layer;
+       private_backend = private_layer->private_backend;
+       func_layer = &private_backend->func_layer;
 
        if (private_layer->usable)
                TDM_INFO("layer(%p) not usable", private_layer);
@@ -501,12 +527,12 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 INTERN tdm_error
 tdm_layer_unset_buffer_internal(tdm_private_layer *private_layer)
 {
-       tdm_private_output *private_output = private_layer->private_output;
-       tdm_private_display *private_display = private_output->private_display;
+       tdm_private_backend *private_backend;
        tdm_func_layer *func_layer;
        tdm_error ret = TDM_ERROR_NONE;
 
-       func_layer = &private_display->func_layer;
+       private_backend = private_layer->private_backend;
+       func_layer = &private_backend->func_layer;
 
        _tdm_layer_free_all_buffers(private_layer);
 
@@ -536,6 +562,7 @@ tdm_layer_unset_buffer(tdm_layer *layer)
        _pthread_mutex_lock(&private_display->lock);
 
        ret = tdm_layer_unset_buffer_internal(private_layer);
+       TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
        _pthread_mutex_unlock(&private_display->lock);
 
@@ -713,6 +740,8 @@ _tdm_layer_cb_output_commit(tdm_output *output, unsigned int sequence,
 
        private_layer = layer_commit_handler->private_layer;
 
+       private_layer->committing = 0;
+
        if (tdm_debug_module & TDM_DEBUG_COMMIT)
                TDM_INFO("layer(%p) commit: output(%d) committed. handle(%p)",
                                 private_layer, private_output->pipe, layer_commit_handler);
@@ -723,7 +752,7 @@ _tdm_layer_cb_output_commit(tdm_output *output, unsigned int sequence,
 
        if (layer_commit_handler->func) {
                _pthread_mutex_unlock(&private_display->lock);
-               layer_commit_handler->func(private_output, sequence,
+               layer_commit_handler->func(private_layer, sequence,
                                                                   tv_sec, tv_usec, layer_commit_handler->user_data);
                _pthread_mutex_lock(&private_display->lock);
        }
@@ -818,12 +847,12 @@ _tdm_layer_reset_pending_data(tdm_private_layer *private_layer)
 INTERN tdm_error
 tdm_layer_commit_pending_data(tdm_private_layer *private_layer)
 {
-       tdm_private_output *private_output = private_layer->private_output;
-       tdm_private_display *private_display = private_output->private_display;
+       tdm_private_backend *private_backend;
        tdm_func_layer *func_layer;
        tdm_error ret = TDM_ERROR_NONE;
 
-       func_layer = &private_display->func_layer;
+       private_backend = private_layer->private_backend;
+       func_layer = &private_backend->func_layer;
 
        if (private_layer->pending_info_changed) {
                ret = func_layer->layer_set_info(private_layer->layer_backend, &private_layer->pending_info);
@@ -893,6 +922,11 @@ _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_da
        layer_commit_handler->committed_buffer = private_layer->waiting_buffer;
        private_layer->waiting_buffer = NULL;
 
+       if (private_layer->committing)
+               TDM_WRN("layer(%d) too many commit", private_layer->index);
+       else
+               private_layer->committing = 1;
+
        if (tdm_debug_module & TDM_DEBUG_BUFFER)
                TDM_INFO("layer(%p) waiting_buffer(%p) committed_buffer(%p)",
                                 private_layer, private_layer->waiting_buffer,
@@ -910,11 +944,6 @@ _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_da
        } else {
                TDM_GOTO_IF_FAIL(private_output->commit_type == TDM_COMMIT_TYPE_LAYER, commit_failed);
 
-               if (private_layer->committing)
-                       TDM_WRN("layer(%d) too many commit", private_layer->index);
-               else
-                       private_layer->committing = 1;
-
                if (_tdm_layer_commit_possible(private_layer)) {
                        /* add to layer_commit_handler_list */
                        LIST_ADDTAIL(&layer_commit_handler->link, &private_output->layer_commit_handler_list);
@@ -1031,6 +1060,9 @@ tdm_layer_remove_commit_handler_internal(tdm_layer *layer, tdm_layer_commit_hand
        tdm_private_output *private_output = private_layer->private_output;
        tdm_private_layer_commit_handler *lm = NULL, *lmm = NULL;
 
+       if (!func && !user_data)
+               return;
+
        TDM_RETURN_IF_FAIL(private_layer != NULL);
        TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 
@@ -1083,8 +1115,6 @@ tdm_layer_get_displaying_buffer(tdm_layer *layer, tdm_error *error)
        if (private_layer->showing_buffer) {
                buffer = private_layer->showing_buffer->buffer;
        } else {
-               if (error)
-                       *error = TDM_ERROR_OPERATION_FAILED;
                _pthread_mutex_unlock(&private_display->lock);
                TDM_DBG("layer(%p) showing_buffer is null", private_layer);
                return NULL;
@@ -1099,14 +1129,17 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
 {
        TDM_RETURN_IF_FAIL(data != NULL);
        tdm_layer *layer = data;
+       tdm_private_backend *private_backend;
        tdm_func_layer *func_layer;
-       tbm_surface_h surface = NULL;
+       tbm_surface_h buffer = NULL;
        tdm_private_layer_buffer *layer_buffer;
        LAYER_FUNC_ENTRY_VOID_RETURN();
 
        _pthread_mutex_lock(&private_display->lock);
 
-       func_layer = &private_display->func_layer;
+       private_backend = private_layer->private_backend;
+       func_layer = &private_backend->func_layer;
+
        if (!func_layer->layer_set_buffer) {
                /* LCOV_EXCL_START */
                _pthread_mutex_unlock(&private_display->lock);
@@ -1124,49 +1157,30 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
        }
        LIST_INITHEAD(&layer_buffer->link);
 
-       if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &surface) ||
-               surface == NULL) {
+       if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &buffer) ||
+               buffer == NULL) {
                /* LCOV_EXCL_START */
                TDM_ERR("layer(%p) tbm_surface_queue_acquire() failed surface:%p",
-                               private_layer, surface);
+                               private_layer, buffer);
                _pthread_mutex_unlock(&private_display->lock);
                free(layer_buffer);
                return;
                /* LCOV_EXCL_STOP */
        }
 
-       /* we don't need to handle pending data here because the changes in this function
-        * should be applied immediately. we can't expect calling tdm_layer_commit.
-        */
-       ret = func_layer->layer_set_buffer(private_layer->layer_backend, surface);
-       TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
-       if (ret == TDM_ERROR_NONE) {
-               if (private_layer->waiting_buffer) {
-                       TDM_DBG("layer(%p) drop waiting_buffer(%p)", private_layer, private_layer->waiting_buffer->buffer);
-                       _tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer);
-               }
-
-               private_layer->waiting_buffer = layer_buffer;
-               private_layer->waiting_buffer->buffer = tdm_buffer_ref_backend(surface);
-
-               if (tdm_debug_module & TDM_DEBUG_BUFFER)
-                       TDM_INFO("layer(%p) waiting_buffer(%p)",
-                                        private_layer, private_layer->waiting_buffer->buffer);
+       ret = tdm_layer_set_buffer_internal(private_layer, buffer);
+       if (ret != TDM_ERROR_NONE) {
+               TDM_ERR("tdm_layer_set_buffer_internal failed");
+               _pthread_mutex_unlock(&private_display->lock);
+               return;
+       }
 
-               if (private_output->commit_type == TDM_COMMIT_TYPE_OUTPUT) {
-                       ret = tdm_output_commit_internal(private_layer->private_output, 0, NULL, NULL);
-                       if (ret != TDM_ERROR_NONE)
-                               TDM_ERR("tdm_output_commit_internal() is fail");
-               } else if (private_output->commit_type == TDM_COMMIT_TYPE_LAYER) {
-                       ret = _tdm_layer_commit(private_layer, NULL, NULL);
-                       if (ret != TDM_ERROR_NONE)
-                               TDM_ERR("layer(%p) _tdm_layer_commit() is fail", private_layer);
-               } else {
-                       TDM_NEVER_GET_HERE();
-               }
-       } else
-               _tdm_layer_free_buffer(private_layer, layer_buffer);
+       ret = tdm_layer_commit_internal(private_layer, NULL, NULL);
+       if (ret != TDM_ERROR_NONE) {
+               TDM_ERR("tdm_layer_commit_internal failed");
+               _pthread_mutex_unlock(&private_display->lock);
+               return;
+       }
 
        _pthread_mutex_unlock(&private_display->lock);
 }
@@ -1191,6 +1205,7 @@ _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data)
 EXTERN tdm_error
 tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
 {
+       tdm_private_backend *private_backend;
        tdm_func_layer *func_layer;
        LAYER_FUNC_ENTRY();
 
@@ -1198,7 +1213,8 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
 
        _pthread_mutex_lock(&private_display->lock);
 
-       func_layer = &private_display->func_layer;
+       private_backend = private_layer->private_backend;
+       func_layer = &private_backend->func_layer;
 
        if (private_layer->usable)
                TDM_INFO("layer(%p) not usable", private_layer);
@@ -1264,17 +1280,19 @@ tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
 EXTERN tdm_error
 tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
 {
+       tdm_private_backend *private_backend;
        tdm_func_layer *func_layer;
        LAYER_FUNC_ENTRY();
 
        _pthread_mutex_lock(&private_display->lock);
 
-       func_layer = &private_display->func_layer;
+       private_backend = private_layer->private_backend;
+       func_layer = &private_backend->func_layer;
 
        if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
                TDM_ERR("layer(%p) is not video layer", private_layer);
                _pthread_mutex_unlock(&private_display->lock);
-               return TDM_ERROR_INVALID_PARAMETER;
+               return TDM_ERROR_BAD_REQUEST;
        }
 
        if (!func_layer->layer_set_video_pos) {
@@ -1311,19 +1329,22 @@ tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
 EXTERN tdm_error
 tdm_layer_get_buffer_flags(tdm_layer *layer, unsigned int *flags)
 {
+       tdm_private_backend *private_backend;
        tdm_func_layer *func_layer;
        LAYER_FUNC_ENTRY();
        TDM_RETURN_VAL_IF_FAIL(flags != NULL, TDM_ERROR_INVALID_PARAMETER);
 
        _pthread_mutex_lock(&private_display->lock);
 
-       func_layer = &private_display->func_layer;
+       private_backend = private_layer->private_backend;
+       func_layer = &private_backend->func_layer;
 
        if (!func_layer->layer_get_buffer_flags) {
                /* LCOV_EXCL_START */
+               *flags = 0;
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_ERR("not implemented!!");
-               return TDM_ERROR_NOT_IMPLEMENTED;
+               TDM_INFO("not implemented!!");
+               return TDM_ERROR_NONE;
                /* LCOV_EXCL_STOP */
        }