X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm_display.c;h=0d6e2749fed66fc7ffc799c425eb7f0f14cea4b4;hb=f70d6e1e8c43a47e72c195d171abe893d6629836;hp=76b4ba4f8ea387dc4059b08891c1fbcbbfb3bbc2;hpb=266a7af80550324ec191da7124908c36933ae4f0;p=platform%2Fcore%2Fuifw%2Flibtdm.git diff --git a/src/tdm_display.c b/src/tdm_display.c index 76b4ba4..0d6e274 100644 --- 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 @@ -125,7 +126,7 @@ struct type_name dpms_names[] = { { TDM_OUTPUT_DPMS_OFF, "off" }, }; -static type_name_fn(dpms) +INTERN type_name_fn(dpms) struct type_name status_names[] = { { TDM_OUTPUT_CONN_STATUS_DISCONNECTED, "disconnected" }, @@ -133,7 +134,7 @@ struct type_name status_names[] = { { TDM_OUTPUT_CONN_STATUS_MODE_SETTED, "mode_setted" }, }; -static type_name_fn(status) +INTERN type_name_fn(status) EXTERN tdm_error tdm_display_get_capabilities(tdm_display *dpy, @@ -340,8 +341,8 @@ tdm_display_get_fd(tdm_display *dpy, int *fd) _pthread_mutex_lock(&private_display->lock); - if (private_display->private_thread) - *fd = tdm_thread_get_fd(private_display); + if (tdm_thread_is_running()) + *fd = tdm_thread_get_fd(private_display->private_loop); else *fd = tdm_event_loop_get_fd(private_display); @@ -380,15 +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_thread) - ret = tdm_thread_handle_cb(private_display); + if (tdm_thread_is_running()) + ret = tdm_thread_handle_cb(private_display->private_loop); else ret = tdm_event_loop_dispatch(private_display); - _pthread_mutex_unlock(&private_display->lock); - return ret; } @@ -444,6 +441,48 @@ tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status) return ret; } +INTERN void +tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, + void *user_data) +{ + tdm_private_display *private_display; + tdm_private_output *private_output = user_data; + tdm_value value; + + 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(syscall(SYS_gettid))) { + tdm_thread_cb_output_status output_status; + tdm_error ret; + + output_status.base.type = TDM_THREAD_CB_OUTPUT_STATUS; + output_status.base.length = sizeof output_status; + output_status.output_stamp = private_output->stamp; + output_status.status = status; + output_status.user_data = user_data; + + value.u32 = status; + tdm_output_call_change_handler_internal(private_output, + &private_output->change_handler_list_sub, + TDM_OUTPUT_CHANGE_CONNECTION, + value); + + ret = tdm_thread_send_cb(private_display->private_loop, &output_status.base); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); + + return; + } + + value.u32 = status; + tdm_output_call_change_handler_internal(private_output, + &private_output->change_handler_list_main, + TDM_OUTPUT_CHANGE_CONNECTION, + value); +} + EXTERN tdm_error tdm_output_add_change_handler(tdm_output *output, tdm_output_change_handler func, @@ -458,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; } @@ -469,10 +508,15 @@ tdm_output_add_change_handler(tdm_output *output, return TDM_ERROR_OUT_OF_MEMORY; } - LIST_ADD(&change_handler->link, &private_output->change_handler_list); change_handler->private_output = private_output; change_handler->func = func; change_handler->user_data = user_data; + change_handler->owner_tid = syscall(SYS_gettid); + + 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); _pthread_mutex_unlock(&private_display->lock); @@ -496,7 +540,19 @@ tdm_output_remove_change_handler(tdm_output *output, _pthread_mutex_lock(&private_display->lock); - LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) { + LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_main, link) { + if (h->func != func || h->user_data != user_data) + continue; + + LIST_DEL(&h->link); + free(h); + + _pthread_mutex_unlock(&private_display->lock); + + return; + } + + LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_sub, link) { if (h->func != func || h->user_data != user_data) continue; @@ -701,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; } @@ -727,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; } @@ -746,11 +802,12 @@ 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; - if (!tdm_thread_in_display_thread(private_display)) { + if (vblank_handler->owner_tid != syscall(SYS_gettid)) { tdm_thread_cb_output_vblank output_vblank; tdm_error ret; @@ -762,12 +819,15 @@ tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence, output_vblank.tv_usec = tv_usec; output_vblank.user_data = user_data; - ret = tdm_thread_send_cb(private_display, &output_vblank.base); + ret = tdm_thread_send_cb(private_display->private_loop, &output_vblank.base); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); return; } + if (vblank_handler->owner_tid != syscall(SYS_gettid)) + TDM_NEVER_GET_HERE(); + if (vblank_handler->func) { _pthread_mutex_unlock(&private_display->lock); vblank_handler->func(vblank_handler->private_output, sequence, @@ -788,12 +848,13 @@ tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence, tdm_private_output *private_output; tdm_private_layer *private_layer = NULL; + TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); TDM_RETURN_IF_FAIL(commit_handler); private_output = commit_handler->private_output; private_display = private_output->private_display; - if (!tdm_thread_in_display_thread(private_display)) { + if (commit_handler->owner_tid != syscall(SYS_gettid)) { tdm_thread_cb_output_commit output_commit; tdm_error ret; @@ -805,7 +866,7 @@ tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence, output_commit.tv_usec = tv_usec; output_commit.user_data = user_data; - ret = tdm_thread_send_cb(private_display, &output_commit.base); + ret = tdm_thread_send_cb(private_display->private_loop, &output_commit.base); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); return; @@ -821,10 +882,8 @@ tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence, _pthread_mutex_lock(&private_display->lock); if (private_layer->buffer_queue) { - _pthread_mutex_unlock(&private_display->lock); tbm_surface_queue_release(private_layer->buffer_queue, private_layer->showing_buffer); - _pthread_mutex_lock(&private_display->lock); } } @@ -858,11 +917,18 @@ 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_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; + } + func_output = &private_display->func_output; 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; } @@ -877,6 +943,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync, vblank_handler->private_output = private_output; vblank_handler->func = func; vblank_handler->user_data = user_data; + vblank_handler->owner_tid = syscall(SYS_gettid); ret = func_output->output_wait_vblank(private_output->output_backend, interval, sync, vblank_handler); @@ -907,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; } @@ -921,6 +988,7 @@ _tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, commit_handler->private_output = private_output; commit_handler->func = func; commit_handler->user_data = user_data; + commit_handler->owner_tid = syscall(SYS_gettid); ret = func_output->output_commit(private_output->output_backend, sync, commit_handler); @@ -943,6 +1011,13 @@ 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_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; + } + ret = _tdm_output_commit(output, sync, func, user_data); _pthread_mutex_unlock(&private_display->lock); @@ -964,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; } @@ -989,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; } @@ -1013,15 +1088,32 @@ 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) { + 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); @@ -1041,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); @@ -1072,31 +1165,38 @@ tdm_output_create_capture(tdm_output *output, tdm_error *error) INTERN void tdm_output_call_change_handler_internal(tdm_private_output *private_output, + struct list_head *change_handler_list, tdm_output_change_type type, tdm_value value) { - tdm_private_change_handler *change_handler; 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(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); + if (type & TDM_OUTPUT_CHANGE_DPMS) + TDM_INFO("output(%d) changed: dpms %s (%d)", + private_output->pipe, dpms_str(value.u32), value.u32); + } - if (type & TDM_OUTPUT_CHANGE_CONNECTION) - TDM_INFO("output(%d) changed: %s", - private_output->pipe, status_str(value.u32)); - if (type & TDM_OUTPUT_CHANGE_DPMS) - TDM_INFO("output(%d) changed: dpms %s", - private_output->pipe, dpms_str(value.u32)); + if (LIST_IS_EMPTY(change_handler_list)) + return; - _pthread_mutex_unlock(&private_display->lock); + LIST_FOR_EACH_ENTRY(change_handler, change_handler_list, link) { + if (change_handler->owner_tid != syscall(SYS_gettid)) + TDM_NEVER_GET_HERE(); - LIST_FOR_EACH_ENTRY(change_handler, &private_output->change_handler_list, link) { + _pthread_mutex_unlock(&private_display->lock); change_handler->func(private_output, type, value, change_handler->user_data); + _pthread_mutex_lock(&private_display->lock); } - - _pthread_mutex_lock(&private_display->lock); } EXTERN tdm_error @@ -1181,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; } @@ -1206,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; } @@ -1233,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; } @@ -1268,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; } @@ -1279,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) { @@ -1296,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. @@ -1360,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; } @@ -1463,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; } @@ -1540,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; } @@ -1585,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; }