Merge branch 'tizen' into sandbox/cyeon/devel

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

diff --git a/src/tdm_layer.c b/src/tdm_layer.c
index 0885abb..b6f07f0 100644 (file)
--- a/src/tdm_layer.c
+++ b/src/tdm_layer.c
@@ -71,6 +71,29 @@
        private_output = private_layer->private_output; \
        private_display = private_output->private_display
 
+#define OUTPUT_HWC_CAP_CHECK() \
+       if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) { \
+               TDM_ERR("output(%p) support HWC. Use HWC functions", private_output); \
+               _pthread_mutex_unlock(&private_display->lock); \
+               return TDM_ERROR_OPERATION_FAILED; \
+       }
+
+#define OUTPUT_HWC_CAP_CHECK_ERROR() \
+       if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) { \
+               TDM_ERR("output(%p) support HWC. Use HWC functions", private_output); \
+               if (error) *error = TDM_ERROR_OPERATION_FAILED; \
+               _pthread_mutex_unlock(&private_display->lock); \
+               return NULL; \
+       }
+
+#define OUTPUT_HWC_CAP_CHECK_VOID_RETURN() \
+       if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)  { \
+               TDM_ERR("output(%p) support HWC. Use HWC functions", private_output); \
+               _pthread_mutex_unlock(&private_display->lock); \
+               return; \
+       }
+
+/* LCOV_EXCL_START */
 static void _tdm_layer_cb_wait_vblank(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
                                                                          unsigned int tv_sec, unsigned int tv_usec, void *user_data);
 static void _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data);
@@ -88,6 +111,8 @@ tdm_layer_get_output(tdm_layer *layer, tdm_error *error)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK_ERROR();
+
        if (error)
                *error = TDM_ERROR_NONE;
 
@@ -107,6 +132,8 @@ tdm_layer_get_index(tdm_layer *layer, int *index)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        *index = private_layer->index;
 
        _pthread_mutex_unlock(&private_display->lock);
@@ -123,6 +150,8 @@ tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        *capabilities = private_layer->caps.capabilities;
 
        _pthread_mutex_unlock(&private_display->lock);
@@ -140,6 +169,8 @@ tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, in
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        *formats = (const tbm_format *)private_layer->caps.formats;
        *count = private_layer->caps.format_count;
 
@@ -158,6 +189,8 @@ tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        *props = (const tdm_prop *)private_layer->caps.props;
        *count = private_layer->caps.prop_count;
 
@@ -175,6 +208,8 @@ tdm_layer_get_zpos(tdm_layer *layer, int *zpos)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        *zpos = private_layer->caps.zpos;
 
        _pthread_mutex_unlock(&private_display->lock);
@@ -191,6 +226,8 @@ tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        private_module = private_layer->private_module;
        func_layer = &private_module->func_layer;
 
@@ -200,11 +237,9 @@ tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
        private_layer->usable = 0;
 
        if (!func_layer->layer_set_property) {
-               /* LCOV_EXCL_START */
                _pthread_mutex_unlock(&private_display->lock);
                TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
-               /* LCOV_EXCL_STOP */
        }
 
        ret = func_layer->layer_set_property(private_layer->layer_backend, id, value);
@@ -225,15 +260,15 @@ tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        private_module = private_layer->private_module;
        func_layer = &private_module->func_layer;
 
        if (!func_layer->layer_get_property) {
-               /* LCOV_EXCL_START */
                _pthread_mutex_unlock(&private_display->lock);
                TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
-               /* LCOV_EXCL_SOP */
        }
 
        ret = func_layer->layer_get_property(private_layer->layer_backend, id, value);
@@ -259,10 +294,8 @@ tdm_layer_set_info_internal(tdm_private_layer *private_layer, tdm_info_layer *in
        private_layer->usable = 0;
 
        if (!func_layer->layer_set_info) {
-               /* LCOV_EXCL_START */
                TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
-               /* LCOV_EXCL_STOP */
        }
 
        if (info->src_config.format)
@@ -295,6 +328,8 @@ tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        ret = tdm_layer_set_info_internal(private_layer, info);
 
        _pthread_mutex_unlock(&private_display->lock);
@@ -313,15 +348,15 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        private_module = private_layer->private_module;
        func_layer = &private_module->func_layer;
 
        if (!func_layer->layer_get_info) {
-               /* LCOV_EXCL_START */
                _pthread_mutex_unlock(&private_display->lock);
                TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
-               /* LCOV_EXCL_STOP */
        }
 
        ret = func_layer->layer_get_info(private_layer->layer_backend, info);
@@ -331,7 +366,6 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
        return ret;
 }
 
-/* LCOV_EXCL_START */
 static void
 _tdm_layer_dump_buffer(tdm_layer *layer, tbm_surface_h buffer)
 {
@@ -343,6 +377,7 @@ _tdm_layer_dump_buffer(tdm_layer *layer, tbm_surface_h buffer)
        tdm_private_layer *l = NULL;
        char *p = bufs;
        int *remain = &len;
+       int n;
 
        pipe = private_output->pipe;
        zpos = private_layer->caps.zpos;
@@ -354,14 +389,16 @@ _tdm_layer_dump_buffer(tdm_layer *layer, tbm_surface_h buffer)
                TDM_SNPRINTF(p, remain, "_%p", l->showing_buffer->buffer);
        }
 
-       snprintf(fname, sizeof(fname), "tdm_%d_lyr_%d%s", pipe, zpos, bufs);
+       n = snprintf(fname, sizeof(fname), "tdm_%d_lyr_%d%s", pipe, zpos, bufs);
+       if ((size_t)n >= sizeof(fname)) {
+               fname[sizeof(fname) - 1] = '\0';
+       }
 
        tbm_surface_internal_dump_buffer(buffer, fname);
        TDM_DBG("%s dump excute", fname);
 
        return;
 }
-/* LCOV_EXCL_STOP */
 
 void
 tdm_layer_free_buffer(tdm_private_layer *private_layer, tdm_private_layer_buffer *layer_buffer)
@@ -463,7 +500,6 @@ tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h bu
        tdm_private_output *private_output = private_layer->private_output;
        tdm_func_layer *func_layer;
 
-       /* LCOV_EXCL_START */
        /* dump buffer */
        if (tdm_dump_enable && !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO))
                _tdm_layer_dump_buffer(private_layer, buffer);
@@ -476,7 +512,6 @@ tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h bu
                                 private_output->index, private_layer->index, i++);
                tdm_helper_dump_buffer_str(buffer, tdm_debug_dump_dir, str);
        }
-       /* LCOV_EXCL_STOP */
 
        private_module = private_layer->private_module;
        func_layer = &private_module->func_layer;
@@ -487,10 +522,8 @@ tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h bu
        private_layer->usable = 0;
 
        if (!func_layer->layer_set_buffer) {
-               /* LCOV_EXCL_START */
                TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
-               /* LCOV_EXCL_START */
        }
 
        private_layer->pending_buffer_changed = 1;
@@ -536,6 +569,8 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        ret = tdm_layer_set_buffer_internal(private_layer, buffer);
 
        _pthread_mutex_unlock(&private_display->lock);
@@ -561,10 +596,8 @@ tdm_layer_unset_buffer_internal(tdm_private_layer *private_layer)
                TDM_INFO("layer(%p,%d) now usable", private_layer, private_layer->index);
 
        if (!func_layer->layer_unset_buffer) {
-               /* LCOV_EXCL_START */
                TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
-               /* LCOV_EXCL_START */
        }
 
        ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
@@ -580,6 +613,8 @@ tdm_layer_unset_buffer(tdm_layer *layer)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        ret = tdm_layer_unset_buffer_internal(private_layer);
        TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
@@ -594,7 +629,6 @@ tdm_layer_committed(tdm_private_layer *private_layer, tdm_private_layer_buffer *
        tdm_private_output *private_output = private_layer->private_output;
        tdm_private_display *private_display = private_output->private_display;
 
-       /* LCOV_EXCL_START */
        if (private_display->print_fps) {
                double curr = tdm_helper_get_time();
                if (private_layer->fps_stamp == 0) {
@@ -610,7 +644,6 @@ tdm_layer_committed(tdm_private_layer *private_layer, tdm_private_layer_buffer *
                private_layer->fps_stamp = 0;
                private_layer->fps_count = 0;
        }
-       /* LCOV_EXCL_STOP */
 
        if (private_layer->showing_buffer) {
                if (tdm_ttrace_module & TDM_TTRACE_LAYER) {
@@ -927,10 +960,8 @@ _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_da
 
        layer_commit_handler = calloc(1, sizeof(tdm_private_layer_commit_handler));
        if (!layer_commit_handler) {
-               /* LCOV_EXCL_START */
                TDM_ERR("failed: alloc memory");
                return TDM_ERROR_OUT_OF_MEMORY;
-               /* LCOV_EXCL_STOP */
        }
 
        if (tdm_debug_module & TDM_DEBUG_COMMIT)
@@ -998,7 +1029,14 @@ _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_da
                        _pthread_mutex_unlock(&private_display->lock);
                        ret = tdm_vblank_wait(private_output->vblank, 0, 0, 1, _tdm_layer_cb_wait_vblank, private_output);
                        _pthread_mutex_lock(&private_display->lock);
-                       TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
+                       if (ret != TDM_ERROR_NONE) {
+                               if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
+                                       /* dpms off : the allocated memory was free in tdm_output_commit_internal */
+                                       return ret;
+                               }
+                               goto commit_failed;
+
+                       }
                        private_output->layer_waiting_vblank = 1;
 
                        if (tdm_debug_module & TDM_DEBUG_COMMIT)
@@ -1055,6 +1093,8 @@ tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_dat
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        ret = tdm_layer_commit_internal(private_layer, func, user_data);
 
        _pthread_mutex_unlock(&private_display->lock);
@@ -1071,6 +1111,8 @@ tdm_layer_is_committing(tdm_layer *layer, unsigned int *committing)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        *committing = private_layer->committing;
 
        _pthread_mutex_unlock(&private_display->lock);
@@ -1119,6 +1161,8 @@ tdm_layer_remove_commit_handler(tdm_layer *layer, tdm_layer_commit_handler func,
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        tdm_layer_remove_commit_handler_internal(layer, func, user_data);
 
        _pthread_mutex_unlock(&private_display->lock);
@@ -1134,6 +1178,8 @@ tdm_layer_get_displaying_buffer(tdm_layer *layer, tdm_error *error)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK_ERROR();
+
        if (error)
                *error = TDM_ERROR_NONE;
 
@@ -1165,20 +1211,16 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
        func_layer = &private_module->func_layer;
 
        if (!func_layer->layer_set_buffer) {
-               /* LCOV_EXCL_START */
                _pthread_mutex_unlock(&private_display->lock);
                return;
-               /* LCOV_EXCL_STOP */
        }
 
        if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &buffer) ||
                buffer == NULL) {
-               /* LCOV_EXCL_START */
                TDM_ERR("layer(%p,%d) tbm_surface_queue_acquire() failed surface:%p",
                                private_layer, private_layer->index, buffer);
                _pthread_mutex_unlock(&private_display->lock);
                return;
-               /* LCOV_EXCL_STOP */
        }
 
        ret = tdm_layer_set_buffer_internal(private_layer, buffer);
@@ -1226,6 +1268,8 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        private_module = private_layer->private_module;
        func_layer = &private_module->func_layer;
 
@@ -1235,11 +1279,9 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
        private_layer->usable = 0;
 
        if (!func_layer->layer_set_buffer) {
-               /* LCOV_EXCL_START */
                _pthread_mutex_unlock(&private_display->lock);
                TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
-               /* LCOV_EXCL_STOP */
        }
 
        if (buffer_queue == private_layer->buffer_queue) {
@@ -1283,6 +1325,8 @@ tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        *usable = private_layer->usable;
 
        _pthread_mutex_unlock(&private_display->lock);
@@ -1299,6 +1343,8 @@ tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        private_module = private_layer->private_module;
        func_layer = &private_module->func_layer;
 
@@ -1309,11 +1355,9 @@ tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
        }
 
        if (!func_layer->layer_set_video_pos) {
-               /* LCOV_EXCL_START */
                _pthread_mutex_unlock(&private_display->lock);
                TDM_ERR("layer(%p,%d) not implemented!!", private_layer, private_layer->index);
                return TDM_ERROR_NOT_IMPLEMENTED;
-               /* LCOV_EXCL_STOP */
        }
 
        ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos);
@@ -1332,6 +1376,8 @@ tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK_ERROR();
+
        capture = (tdm_capture *)tdm_capture_create_layer_internal(private_layer, error);
 
        _pthread_mutex_unlock(&private_display->lock);
@@ -1349,16 +1395,16 @@ tdm_layer_get_buffer_flags(tdm_layer *layer, unsigned int *flags)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       OUTPUT_HWC_CAP_CHECK();
+
        private_module = private_layer->private_module;
        func_layer = &private_module->func_layer;
 
        if (!func_layer->layer_get_buffer_flags) {
-               /* LCOV_EXCL_START */
                *flags = 0;
                _pthread_mutex_unlock(&private_display->lock);
                TDM_INFO("not implemented!!");
                return TDM_ERROR_NONE;
-               /* LCOV_EXCL_STOP */
        }
 
        ret = func_layer->layer_get_buffer_flags(private_layer->layer_backend, flags);
@@ -1367,3 +1413,4 @@ tdm_layer_get_buffer_flags(tdm_layer *layer, unsigned int *flags)
 
        return ret;
 }
+/* LCOV_EXCL_STOP */