#include "tdm.h"
#include "tdm_backend.h"
#include "tdm_private.h"
+#include "tdm_helper.h"
#define COUNT_MAX 10
{ 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" },
{ 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,
_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);
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;
}
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,
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;
}
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);
_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;
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;
}
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;
}
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;
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,
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;
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;
_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);
}
}
_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;
}
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);
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;
}
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);
_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);
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;
}
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;
}
_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);
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);
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
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;
}
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;
}
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;
}
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;
}
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)
{
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.
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;
}
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;
}
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;
}
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;
}
projects / platform / core / uifw / libtdm.git / blobdiff