projects / platform / core / uifw / libtdm.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
enhance log
[platform/core/uifw/libtdm.git] / src / tdm_display.c
diff --git a/src/tdm_display.c b/src/tdm_display.c
index d804f9d..0d6e274 100644 (file)
--- a/src/tdm_display.c
+++ b/src/tdm_display.c
@@ -40,6 +40,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "tdm.h"
 #include "tdm_backend.h"
 #include "tdm_private.h"
+#include "tdm_helper.h"
 
 #define COUNT_MAX   10
 
@@ -340,11 +341,8 @@ tdm_display_get_fd(tdm_display *dpy, int *fd)
 
        _pthread_mutex_lock(&private_display->lock);
 
-       if (private_display->private_loop->private_thread) {
-               _pthread_mutex_unlock(&private_display->lock);
+       if (tdm_thread_is_running())
                *fd = tdm_thread_get_fd(private_display->private_loop);
-               _pthread_mutex_lock(&private_display->lock);
-       }
        else
                *fd = tdm_event_loop_get_fd(private_display);
 
@@ -383,18 +381,11 @@ tdm_display_handle_events(tdm_display *dpy)
        if (tdm_debug_thread)
                TDM_INFO("fd(%d) polling out", fd);
 
-       _pthread_mutex_lock(&private_display->lock);
-
-       if (private_display->private_loop->private_thread) {
-               _pthread_mutex_unlock(&private_display->lock);
+       if (tdm_thread_is_running())
                ret = tdm_thread_handle_cb(private_display->private_loop);
-               _pthread_mutex_lock(&private_display->lock);
-       }
        else
                ret = tdm_event_loop_dispatch(private_display);
 
-       _pthread_mutex_unlock(&private_display->lock);
-
        return ret;
 }
 
@@ -457,15 +448,13 @@ tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status,
        tdm_private_display *private_display;
        tdm_private_output *private_output = user_data;
        tdm_value value;
-       int lock_after_cb_done = 0;
-       int ret;
 
+       TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
        TDM_RETURN_IF_FAIL(private_output);
 
        private_display = private_output->private_display;
 
-       if (!tdm_thread_in_display_thread(private_display->private_loop,
-                                         syscall(SYS_gettid))) {
+       if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
                tdm_thread_cb_output_status output_status;
                tdm_error ret;
 
@@ -487,22 +476,11 @@ tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status,
                return;
        }
 
-       ret = pthread_mutex_trylock(&private_display->lock);
-       if (ret == 0)
-               _pthread_mutex_unlock(&private_display->lock);
-       else  if (ret == EBUSY) {
-               _pthread_mutex_unlock(&private_display->lock);
-               lock_after_cb_done = 1;
-       }
-
        value.u32 = status;
        tdm_output_call_change_handler_internal(private_output,
                                                &private_output->change_handler_list_main,
                                                TDM_OUTPUT_CHANGE_CONNECTION,
                                                value);
-
-       if (lock_after_cb_done)
-               _pthread_mutex_lock(&private_display->lock);
 }
 
 EXTERN tdm_error
@@ -519,7 +497,7 @@ tdm_output_add_change_handler(tdm_output *output,
 
        if (!private_output->regist_change_cb) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -535,8 +513,7 @@ tdm_output_add_change_handler(tdm_output *output,
        change_handler->user_data = user_data;
        change_handler->owner_tid = syscall(SYS_gettid);
 
-       if (!tdm_thread_in_display_thread(private_display->private_loop,
-                                         change_handler->owner_tid))
+       if (!tdm_thread_in_display_thread(change_handler->owner_tid))
                LIST_ADD(&change_handler->link, &private_output->change_handler_list_sub);
        else
                LIST_ADD(&change_handler->link, &private_output->change_handler_list_main);
@@ -780,7 +757,7 @@ tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
 
        if (!func_output->output_set_property) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -806,7 +783,7 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
 
        if (!func_output->output_get_property) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -825,6 +802,7 @@ tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
        tdm_private_vblank_handler *vblank_handler = user_data;
        tdm_private_display *private_display;
 
+       TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
        TDM_RETURN_IF_FAIL(vblank_handler);
 
        private_display = vblank_handler->private_output->private_display;
@@ -851,22 +829,10 @@ tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
                TDM_NEVER_GET_HERE();
 
        if (vblank_handler->func) {
-               int lock_after_cb_done = 0;
-               int ret;
-
-               ret = pthread_mutex_trylock(&private_display->lock);
-               if (ret == 0)
-                       _pthread_mutex_unlock(&private_display->lock);
-               else  if (ret == EBUSY) {
-                       _pthread_mutex_unlock(&private_display->lock);
-                       lock_after_cb_done = 1;
-               }
-
+               _pthread_mutex_unlock(&private_display->lock);
                vblank_handler->func(vblank_handler->private_output, sequence,
                                     tv_sec, tv_usec, vblank_handler->user_data);
-
-               if (lock_after_cb_done)
-                       _pthread_mutex_lock(&private_display->lock);
+               _pthread_mutex_lock(&private_display->lock);
        }
 
        LIST_DEL(&vblank_handler->link);
@@ -881,9 +847,8 @@ tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
        tdm_private_display *private_display;
        tdm_private_output *private_output;
        tdm_private_layer *private_layer = NULL;
-       int lock_after_cb_done = 0;
-       int ret;
 
+       TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
        TDM_RETURN_IF_FAIL(commit_handler);
 
        private_output = commit_handler->private_output;
@@ -907,20 +872,14 @@ tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
                return;
        }
 
-       ret = pthread_mutex_trylock(&private_display->lock);
-       if (ret == 0)
-               _pthread_mutex_unlock(&private_display->lock);
-       else  if (ret == EBUSY) {
-               _pthread_mutex_unlock(&private_display->lock);
-               lock_after_cb_done = 1;
-       }
-
        LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
                if (!private_layer->waiting_buffer)
                        continue;
 
                if (private_layer->showing_buffer) {
+                       _pthread_mutex_unlock(&private_display->lock);
                        tdm_buffer_unref_backend(private_layer->showing_buffer);
+                       _pthread_mutex_lock(&private_display->lock);
 
                        if (private_layer->buffer_queue) {
                                tbm_surface_queue_release(private_layer->buffer_queue,
@@ -938,12 +897,11 @@ tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
        }
 
        if (commit_handler->func) {
+               _pthread_mutex_unlock(&private_display->lock);
                commit_handler->func(private_output, sequence,
                                     tv_sec, tv_usec, commit_handler->user_data);
-       }
-
-       if (lock_after_cb_done)
                _pthread_mutex_lock(&private_display->lock);
+       }
 
        LIST_DEL(&commit_handler->link);
        free(commit_handler);
@@ -960,7 +918,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
        _pthread_mutex_lock(&private_display->lock);
 
        if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
-               TDM_WRN("output(%d) dpms: %s", private_output->pipe,
+               TDM_ERR("output(%d) dpms: %s", private_output->pipe,
                        dpms_str(private_output->current_dpms_value));
                _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_BAD_REQUEST;
@@ -970,7 +928,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
 
        if (!func_output->output_wait_vblank) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -1016,7 +974,7 @@ _tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
        func_output = &private_display->func_output;
 
        if (!func_output->output_commit) {
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -1054,7 +1012,7 @@ tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
        _pthread_mutex_lock(&private_display->lock);
 
        if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
-               TDM_WRN("output(%d) dpms: %s", private_output->pipe,
+               TDM_ERR("output(%d) dpms: %s", private_output->pipe,
                        dpms_str(private_output->current_dpms_value));
                _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_BAD_REQUEST;
@@ -1081,7 +1039,7 @@ tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
 
        if (!func_output->output_set_mode) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -1106,7 +1064,7 @@ tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
 
        if (!func_output->output_get_mode) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -1130,18 +1088,33 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
 
        _pthread_mutex_lock(&private_display->lock);
 
+       if (private_output->current_dpms_value == dpms_value) {
+               _pthread_mutex_unlock(&private_display->lock);
+               return TDM_ERROR_NONE;
+       }
+
        func_output = &private_display->func_output;
 
        if (!func_output->output_set_dpms) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
-               return TDM_ERROR_NOT_IMPLEMENTED;
+               private_output->current_dpms_value = dpms_value;
+               TDM_WRN("not implemented!!");
+               return TDM_ERROR_NONE;
        }
 
        ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
-       if (ret == TDM_ERROR_NONE)
+       if (ret == TDM_ERROR_NONE) {
+               tdm_value value;
+
                private_output->current_dpms_value = dpms_value;
 
+               value.u32 = dpms_value;
+               tdm_output_call_change_handler_internal(private_output,
+                                                       &private_output->change_handler_list_main,
+                                                       TDM_OUTPUT_CHANGE_DPMS,
+                                                       value);
+       }
+
        _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
@@ -1160,9 +1133,10 @@ tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
        func_output = &private_display->func_output;
 
        if (!func_output->output_get_dpms) {
+               *dpms_value = private_output->current_dpms_value;
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
-               return TDM_ERROR_NOT_IMPLEMENTED;
+               TDM_WRN("not implemented!!");
+               return TDM_ERROR_NONE;
        }
 
        ret = func_output->output_get_dpms(private_output->output_backend, dpms_value);
@@ -1198,11 +1172,11 @@ tdm_output_call_change_handler_internal(tdm_private_output *private_output,
        tdm_private_display *private_display;
        tdm_private_change_handler *change_handler;
 
+       TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
        TDM_RETURN_IF_FAIL(private_output);
 
        private_display = private_output->private_display;
-       if (!tdm_thread_in_display_thread(private_display->private_loop,
-                                         syscall(SYS_gettid))) {
+       if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
                if (type & TDM_OUTPUT_CHANGE_CONNECTION)
                        TDM_INFO("output(%d) changed: %s (%d)",
                                 private_output->pipe, status_str(value.u32), value.u32);
@@ -1218,8 +1192,10 @@ tdm_output_call_change_handler_internal(tdm_private_output *private_output,
                if (change_handler->owner_tid != syscall(SYS_gettid))
                        TDM_NEVER_GET_HERE();
 
+               _pthread_mutex_unlock(&private_display->lock);
                change_handler->func(private_output, type,
                                     value, change_handler->user_data);
+               _pthread_mutex_lock(&private_display->lock);
        }
 }
 
@@ -1305,7 +1281,7 @@ tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
 
        if (!func_layer->layer_set_property) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -1330,7 +1306,7 @@ tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
 
        if (!func_layer->layer_get_property) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -1357,7 +1333,7 @@ tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
 
        if (!func_layer->layer_set_info) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -1392,7 +1368,7 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
 
        if (!func_layer->layer_get_info) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -1403,6 +1379,48 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
        return ret;
 }
 
+static void
+_tdm_layer_dump_buffer(tdm_layer *layer, tbm_surface_h buffer)
+{
+       tdm_private_layer *private_layer = (tdm_private_layer*)layer;
+       tdm_private_output *private_output = private_layer->private_output;
+       char *path = NULL;
+       int count;
+       unsigned int pipe;
+       int zpos;
+       char fullpath[PATH_MAX];
+       tbm_surface_info_s info;
+       tbm_surface_error_e err;
+
+       path = tdm_helper_get_dump_path();
+       if (!path)
+               return;
+
+       count = tdm_helper_get_dump_count();
+       if (count <= 0)
+               return;
+
+       err = tbm_surface_map(buffer, TBM_SURF_OPTION_READ, &info);
+       TDM_RETURN_IF_FAIL(err == TBM_SURFACE_ERROR_NONE);
+
+       pipe = private_output->pipe;
+       zpos = private_layer->caps.zpos;
+
+       if (info.format == TBM_FORMAT_ARGB8888 || info.format == TBM_FORMAT_XRGB8888)
+               snprintf(fullpath, sizeof(fullpath), "%s/%03d_out_%d_lyr_%d.png",
+                       path, count, pipe, zpos);
+       else
+               snprintf(fullpath, sizeof(fullpath), "%s/%03d_out_%d_lyr_%d_%dx%d_%c%c%c%c.yuv",
+                       path, count, pipe, zpos, info.planes[0].stride, info.height, FOURCC_STR(info.format));
+
+       tbm_surface_unmap(buffer);
+
+       tdm_helper_dump_buffer(buffer, fullpath);
+       TDM_DBG("%d, %s dump excute", count, fullpath);
+
+       return;
+}
+
 EXTERN tdm_error
 tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 {
@@ -1420,13 +1438,17 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 
        if (!func_layer->layer_set_buffer) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
        ret = func_layer->layer_set_buffer(private_layer->layer_backend, buffer);
        TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
+       /* dump buffer */
+       if (tdm_dump_enable)
+               _tdm_layer_dump_buffer(layer, buffer);
+
        if (ret == TDM_ERROR_NONE) {
                /* FIXME: should save to pending_buffer first. And after committing
                 * successfully, need to move to waiting_buffer.
@@ -1484,7 +1506,7 @@ tdm_layer_unset_buffer(tdm_layer *layer)
 
        if (!func_layer->layer_unset_buffer) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -1587,7 +1609,7 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
 
        if (!func_layer->layer_set_buffer) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -1664,7 +1686,7 @@ tdm_layer_unset_buffer_queue(tdm_layer *layer)
 
        if (!func_layer->layer_unset_buffer) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
@@ -1709,7 +1731,7 @@ tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
 
        if (!func_layer->layer_set_video_pos) {
                _pthread_mutex_unlock(&private_display->lock);
-               TDM_DBG("failed: not implemented!!");
+               TDM_ERR("not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
Domain: Graphics System / Display Management;